@uniweb/core 0.18.0 → 0.20.0

package/src/fetcher-dispatcher.js

@@ -160,7 +160,12 @@ export default class FetcherDispatcher {
 
     const transportsConfig = ctx?.website?.config?.fetcher?.transports
     if (transportsConfig && typeof transportsConfig === 'object') {
-      const schema = request?.schema
+      // ⛔ `as`, the binding key. This read `request.schema` — and ONLY that —
+      // so from the 2026-09-02 rename until this line was fixed, a site's
+      // `transports:` selection silently missed on every `as`-keyed payload and
+      // fell through to the default transport. No warning: the miss is
+      // indistinguishable from "this site declared no transport for it".
+      const schema = request?.as
       const name = (schema && transportsConfig[schema]) || transportsConfig.default
       if (name) {
         const t = this._namedTransports.get(name)
@@ -199,6 +204,18 @@ export default class FetcherDispatcher {
     return this._dataStore.get(key)
   }
 
+  /**
+   * The record held under an identity, if any, with its depth — the entity
+   * store asks this before fetching a detail record, so a record already held
+   * in full is delivered rather than fetched again (R1).
+   *
+   * @param {string} id - a `$uuid`
+   * @returns {{ depth: 'brief'|'full', record: Object } | null}
+   */
+  peekRecord(id) {
+    return this._dataStore.getRecord(id)
+  }
+
   /**
    * Full dispatch — selection, cache check, in-flight dedup, execution.
    *

package/src/index.js

@@ -13,7 +13,7 @@ export { default as Website } from './website.js'
 export { default as Page } from './page.js'
 export { default as Block } from './block.js'
 export { default as Theme, hasDarkScheme } from './theme.js'
-export { default as DataStore, deriveCacheKey } from './datastore.js'
+export { default as DataStore, deriveCacheKey, recordIdentity } from './datastore.js'
 export { default as EntityStore } from './entity-store.js'
 export { default as FetcherDispatcher } from './fetcher-dispatcher.js'
 export { default as ObservableState } from './observable-state.js'
@@ -30,7 +30,7 @@ export { substitutePlaceholders } from './substitute-placeholders.js'
 // surface and emits a live named re-export for every one, so nothing here can
 // ever be tree-shaken on the hosted lane.
 export { resolveFetchConfigs } from './fetch-config.js'
-export { buildDetailConfig } from './detail-url.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`.
 export {
@@ -48,6 +48,11 @@ export {
   isDataUrl
 } from './data-paths.js'
 export { evaluate as evaluateWhere, match as matchWhere } from './where.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 } 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
@@ -60,10 +65,6 @@ export { isRichSchema } from './schemas.js'
 // since it must not pull the package root into an SSR/Worker bundle.
 export { resolveService, resolveServiceUrl, readServiceOptions } from './services.js'
 export { applyBasePath } from './base-path.js'
-export {
-  resolveStyle as resolveRequestStyle,
-  listStyleNames as listRequestStyleNames
-} from './request-styles/index.js'
 
 /**
  * The singleton Uniweb instance.

package/src/page.js

@@ -111,6 +111,12 @@ export default class Page {
     // Dynamic route context (for pages created from dynamic routes like /blog/:slug)
     this.dynamicContext = pageData.dynamicContext || null
 
+    // A detail page whose URL names no record: the records were loaded and the
+    // param matched none. Set by `Website._createDynamicPage` beside the
+    // 'Not found' title. Documented for years, carried only since 2026-09-04 —
+    // the flag was set on the page DATA and this sealed class dropped it.
+    this.notFound = pageData.notFound === true
+
     // Version context (for pages within versioned sections like /docs/v1/*)
     this.version = pageData.version || null // { id, label, latest, deprecated }
     this.versionMeta = pageData.versionMeta || null // { versions, latestId }

package/src/query-address.js

@@ -50,7 +50,6 @@ import { substitutePlaceholders } from './substitute-placeholders.js'
  * serving records has no such thing: it has content organised somewhere, and what we
  * substitute is a **path** to it. Naming the slot for our file vocabulary put that
  * vocabulary into a string a HOST writes, which makes them reason in our shape.
- * See `kb/framework/architecture/backend-boundary.md` §2.
  */
 const PATH_SLOT = '{path}'
 /** The placeholder a record pattern must carry to address a specific record. */
@@ -111,6 +110,40 @@ export function resolveQueryAddress(query, lane) {
   return substitutePlaceholders(pattern, { path: query })
 }
 
+/**
+ * The QUESTION door a host declares — a POST address with a `{locale}` slot —
+ * substituted for one locale, or `null` when the lane declares none.
+ *
+ * The stamp key is `config.records.query` — read here as a provisional spelling
+ * on 2026-09-04 and NAMED THE SAME DAY by the door's owner (their site-records
+ * contract, §11.4: stamped since 2026-09-04, value `/_records/_query/{locale}`).
+ * One constant, changed in one place should it ever move. Everything downstream
+ * wakes only when a host stamps it AND the payload carries the query's Model ref
+ * (`config.queries`), and stays dark otherwise. The locale is a ROUTE SEGMENT
+ * there, never a query param: a request that cannot name one does not address
+ * this door at all.
+ *
+ * @param {Object|null} lane - `config.records`
+ * @param {string|null} locale - the locale being rendered; required
+ * @returns {string|null}
+ */
+export const QUERY_DOOR_KEY = 'query'
+
+export function resolveQueryDoor(lane, locale) {
+  const pattern = readPattern(lane, QUERY_DOOR_KEY)
+  if (!pattern) return null
+  if (typeof locale !== 'string' || locale.length === 0) return null
+  if (!pattern.includes('{locale}')) {
+    warnOnce(
+      `query:${pattern}`,
+      `config.records.${QUERY_DOOR_KEY} carries no {locale} placeholder; the door takes the ` +
+        `locale as a route segment. Ignoring it.`
+    )
+    return null
+  }
+  return substitutePlaceholders(pattern, { locale })
+}
+
 /**
  * The address pattern for ONE record of a query, with `{param}` left in
  * place for the dynamic-route substitution that happens later.

package/src/route-match.js

@@ -10,13 +10,22 @@
  * literal, while the second consumed the whole name. Two answers to one
  * question, neither wrong on the routes anyone had tried.
  *
- * That is already bad inside one repo. It is worse across them: a host that
- * renders a page server-side has to decide *which* page a path names, and the
- * runtime then hydrates over that decision in the browser. If the two matchers
- * disagree by a single route, the server renders page A and hydration replaces
- * it with page B — silently, and only on the paths that have a pattern, which
- * are exactly the interesting ones. So this is a cross-boundary contract, not
- * an implementation detail, and it is exported rather than merely shared.
+ * That is already bad inside one repo. It is worse across them, because the
+ * matcher answers a question more than one lane asks: *which page does this
+ * path name?* A consumer outside this repo routes with these patterns —
+ * `hosting/framework-surface.json` declares `routePatternToRegex`,
+ * `isDynamicRoute` and `normalizeRoute` read by its `src/routes.js`. Two copies
+ * that disagree by a single route give two answers to page identity, silently,
+ * and only on the paths that have a pattern — which are exactly the interesting
+ * ones. So this is a cross-boundary contract, not an implementation detail, and
+ * it is exported rather than merely shared.
+ *
+ * ⛔ This paragraph used to justify itself with a server-rendering story — "the
+ * server renders page A and hydration replaces it with page B". That premise is
+ * wrong (Diego, 2026-09-04: *the server does not render*) and the argument never
+ * needed it: two answers to page identity are a defect wherever the second
+ * answer is formed. Do not reintroduce a rendering narrative here; what this
+ * module guarantees is that everyone matching a path agrees on the page.
  *
  * Zero-dependency leaf, like `./data-paths.js` and `./locale-config.js`, so a
  * consumer that must not pull core's graph — an edge worker, a build step —
@@ -24,11 +33,19 @@
  *
  * ## The syntax, in full
  *
- * `:param` is the only construct. There are deliberately **no** catch-alls
- * (`*`), **no** optional segments (`?`), and **no** regex constraints — a
- * pattern is not a regular expression, and regex metacharacters in a route are
- * escaped to literals before any substitution happens. Matching is anchored,
- * case-sensitive, and a param captures exactly one non-empty path segment.
+ * `:param` captures exactly one non-empty path segment. `:param*` — the ONE
+ * multi-segment construct, admitted 2026-09-04 by ruling [Diego] for the
+ * `[...path]` route folder — captures one or more segments, slashes intact, and
+ * only as the FINAL segment of a pattern; anywhere else the `*` is the literal it
+ * always was. There are still **no** optional segments (`?`) and **no** regex
+ * constraints — a pattern is not a regular expression, and regex metacharacters in
+ * a route are escaped to literals before any substitution happens. Matching is
+ * anchored and case-sensitive.
+ *
+ * ⚖️ This module said "deliberately no catch-alls" until 2026-09-04. The reversal
+ * is considered, announced to the consumer that imports this leaf before it
+ * landed, and narrow: one construct, final segment only, nothing author-named —
+ * the build emits `:path*` and nothing else.
  *
  * ## What this module does NOT decide
  *
@@ -76,6 +93,9 @@ export function isDynamicRoute(route) {
   return typeof route === 'string' && route.includes(':')
 }
 
+/** The catch-all token, only as a pattern's final segment: `/:path*`. */
+const CATCH_ALL = new RegExp(`/:(${PARAM_NAME})\\*$`)
+
 /**
  * Compile a route pattern to an anchored regex plus its param names.
  *
@@ -83,12 +103,22 @@ export function isDynamicRoute(route) {
  * compile once — an edge worker checking every request against a site's
  * patterns, for instance.
  *
- * @param {string} pattern - e.g. `/blog/:id`
- * @returns {{ regex: RegExp, paramNames: string[] }}
+ * `catchAll` names the `:name*` param when the pattern ends in one, else null —
+ * a caller decoding captures needs to know which one may hold slashes.
+ *
+ * @param {string} pattern - e.g. `/blog/:id`, `/docs/:path*`
+ * @returns {{ regex: RegExp, paramNames: string[], catchAll: string|null }}
  */
 export function routePatternToRegex(pattern) {
   const paramNames = []
-  const source = normalizeRoute(pattern)
+  let head = normalizeRoute(pattern)
+  let catchAll = null
+  const tail = head.match(CATCH_ALL)
+  if (tail) {
+    catchAll = tail[1]
+    head = head.slice(0, tail.index)
+  }
+  let source = head
     // Escape first: a `.` in a route is a literal `.`, not "any character".
     .replace(REGEX_SPECIALS, '\\$&')
     // Then each `:name` becomes one non-empty segment capture.
@@ -96,8 +126,14 @@ export function routePatternToRegex(pattern) {
       paramNames.push(name)
       return '([^/]+)'
     })
+  if (catchAll) {
+    paramNames.push(catchAll)
+    // One or more segments; the segments are separated by literal slashes, and
+    // an empty segment (`//`) is not a segment.
+    source += '/([^/]+(?:/[^/]+)*)'
+  }
 
-  return { regex: new RegExp(`^${source}$`), paramNames }
+  return { regex: new RegExp(`^${source}$`), paramNames, catchAll }
 }
 
 /**
@@ -147,17 +183,116 @@ export function decodeRouteValue(value) {
  * @returns {{ params: Record<string,string> } | null}
  */
 export function matchDynamicRoute(pattern, path) {
-  const { regex, paramNames } = routePatternToRegex(pattern)
+  const { regex, paramNames, catchAll } = routePatternToRegex(pattern)
   const match = normalizeRoute(path).match(regex)
   if (!match) return null
 
   const params = {}
   paramNames.forEach((name, i) => {
-    params[name] = decodeRouteValue(match[i + 1])
+    const raw = match[i + 1]
+    // A catch-all is decoded PER SEGMENT: an encoded slash inside one segment
+    // (`members%2Fada`) stays a value, while the slashes between segments stay
+    // structure. Decoding the whole capture at once would conflate the two.
+    params[name] = name === catchAll
+      ? raw.split('/').map(decodeRouteValue).join('/')
+      : decodeRouteValue(raw)
   })
   return { params }
 }
 
+/**
+ * The three standard variables a multi-segment capture yields — the split rule,
+ * ruled 2026-09-04 [Diego]:
+ *
+ *     /blog/rust/2025/my-post  →  path = rust/2025/my-post   the whole capture
+ *                                 dir  = rust/2025           everything before the last segment
+ *                                 slug = my-post             the last segment — the record's handle
+ *
+ * `slug` means the same thing in both route kinds — in `[slug]` it is the whole
+ * segment — and `dir` is empty for a single segment, so a query written against
+ * one behaves the same under the other.
+ *
+ * @param {string} capture - a decoded `:path*` value
+ * @returns {{ path: string, dir: string, slug: string }}
+ */
+export function splitPathCapture(capture) {
+  const path = typeof capture === 'string' ? capture.replace(/^\/+|\/+$/g, '') : ''
+  const segments = path ? path.split('/') : []
+  return {
+    path,
+    dir: segments.slice(0, -1).join('/'),
+    slug: segments.length ? segments[segments.length - 1] : '',
+  }
+}
+
+/**
+ * The inverse of `splitPathCapture` — a record's own URL path under a
+ * `[...path]` template, from its placement and its handle. `dir` may be empty.
+ *
+ * @param {{ dir?: string|null, slug?: string|null }} parts
+ * @returns {string|null} null when there is no slug to name the record by
+ */
+export function joinPathCapture({ dir, slug } = {}) {
+  if (slug === undefined || slug === null || slug === '') return null
+  const d = typeof dir === 'string' ? dir.replace(/^\/+|\/+$/g, '') : ''
+  return d ? `${d}/${slug}` : String(slug)
+}
+
+/**
+ * Fill a route pattern's params from a record — the ONE encoder for a record's href.
+ *
+ * `/blog/:slug` + `{ slug: 'a post' }` → `/blog/a%20post`. Every value is
+ * `encodeURIComponent`-ed, because the output is a URL: it is compared against
+ * `location.pathname` (`isActive(item.route)`) and matched back through
+ * `matchDynamicRoute`, which decodes what it captures. A raw interpolation and an
+ * encoded one compare unequal on the first slug with a space — and they used to
+ * both exist: the build baked `${base}/${item.slug}` raw into `/data/*.json` while
+ * the runtime interpolated with encoding, and which one a site got was
+ * lane-dependent (measured 2026-09-04). Two producers of one field now call this.
+ *
+ * ⛔ NOT for a file path. The SSG writes `dist/<route>/index.html` from the DECODED
+ * value on purpose — a server decodes the request path before looking a file up,
+ * so `Ada%20Lovelace` on disk would 404 for `/team/Ada%20Lovelace`. A URL and a
+ * filesystem path are different jobs that are supposed to encode differently.
+ *
+ * Returns `null` — never a partial href — when a param has no value on the
+ * record, so a caller degrades to "no link" rather than emitting a broken one.
+ *
+ * @param {string} pattern - a route pattern with `:param` placeholders
+ * @param {Object} values - a record, read by param name
+ * @returns {string|null}
+ */
+export function fillRoutePattern(pattern, values) {
+  if (typeof pattern !== 'string' || !values || typeof values !== 'object') return null
+  let missing = false
+  let head = pattern
+  let tailHref = ''
+  const tail = pattern.match(CATCH_ALL)
+  if (tail) {
+    // A catch-all is filled from the record's placement and handle — the split
+    // rule in reverse (`joinPathCapture`) — with each SEGMENT encoded and the
+    // slashes between them kept as structure. `dir` is the placement; a record
+    // carries it as `path` (the folder `records.yml` put it in), which is why
+    // `path` here is read as the DIRECTORY and never as a composed capture.
+    if (joinPathCapture({ dir: values.dir ?? values.path, slug: values.slug }) === null) return null
+    const dir = String(values.dir ?? values.path ?? '')
+    const segments = dir.split('/').filter(Boolean).map((seg) => encodeURIComponent(seg))
+    // The handle is ONE segment whatever it contains: a `/` inside it is a value.
+    segments.push(encodeURIComponent(String(values.slug)))
+    tailHref = '/' + segments.join('/')
+    head = pattern.slice(0, tail.index)
+  }
+  const href = head.replace(new RegExp(`:(${PARAM_NAME})`, 'g'), (_, name) => {
+    const value = values[name]
+    if (value === undefined || value === null || value === '') {
+      missing = true
+      return ''
+    }
+    return encodeURIComponent(String(value))
+  })
+  return missing ? null : href + tailHref
+}
+
 /**
  * Strip a locale prefix from a route.
  *

package/src/sort.js

@@ -0,0 +1,116 @@
+/**
+ * Sort — ONE evaluator for a query's `sort:`, and the wire spelling it becomes.
+ *
+ * ⛔ SINGLE-KEY, BY RULING [Diego, 2026-09-04]: "I don't think we need multi-key
+ * sorting. We can drop that." Until this module existed `sort:` had THREE
+ * evaluators — the build's `applySort`, the runtime fetcher's fallback, and the
+ * entity store's refine-order sort — and two of them split on commas and honoured
+ * several keys while the one shipped wire dialect documented the same, so a site
+ * authoring `sort: order asc, title asc` worked on the static lane and would have
+ * been refused by the records door, which takes one key. The language is the
+ * INTERSECTION of what both lanes honour, so a comma is refused here rather than
+ * half-honoured somewhere.
+ *
+ * Author spelling, unchanged: `date`, `date asc`, `date desc`. The records door's
+ * spelling is `date` / `-date`; `-date` is accepted on the way in so a value that
+ * came off the wire round-trips, and `sortToWire` produces it on the way out.
+ *
+ * Dotted paths descend into nested objects (`tenure.start`) — kept, like the
+ * predicate evaluator's.
+ *
+ * Zero-dependency leaf: `@uniweb/build` reads it to materialize `/data/<name>.json`
+ * and `@uniweb/runtime` reads it as the fallback over a fetched array, so the two
+ * lanes cannot drift on the one thing a conformance test would otherwise have to
+ * catch by luck.
+ */
+
+/**
+ * Parse an authored `sort:` into `{ field, desc }`.
+ *
+ * Throws on a comma (multi-key) and on a direction word that is neither `asc`
+ * nor `desc`, because both were silently mis-honoured before: the extra keys
+ * were sorted by on one lane and ignored on another, and an unknown direction
+ * sorted ascending. A query with a wrong `sort:` should fail where it is written.
+ *
+ * @param {string|{field:string, desc?:boolean}|null|undefined} sort
+ * @returns {{ field: string, desc: boolean } | null}
+ */
+export function parseSort(sort) {
+  if (sort === undefined || sort === null || sort === '') return null
+  if (typeof sort === 'object') {
+    if (typeof sort.field !== 'string' || sort.field.length === 0) return null
+    return { field: sort.field, desc: sort.desc === true }
+  }
+  const text = String(sort).trim()
+  if (!text) return null
+  if (text.includes(',')) {
+    throw new Error(
+      `[uniweb] sort: "${text}" names more than one key. A query sorts by ONE key ` +
+        `(\`sort: date desc\`); multi-key sorting is not supported on either lane.`
+    )
+  }
+  if (text.startsWith('-')) {
+    const field = text.slice(1).trim()
+    if (!field || /\s/.test(field)) throw new Error(`[uniweb] sort: "${text}" is not a field name.`)
+    return { field, desc: true }
+  }
+  const parts = text.split(/\s+/)
+  if (parts.length > 2) {
+    throw new Error(`[uniweb] sort: "${text}" is not \`<field>\` or \`<field> asc|desc\`.`)
+  }
+  const [field, dir] = parts
+  const lower = dir ? dir.toLowerCase() : 'asc'
+  if (lower !== 'asc' && lower !== 'desc') {
+    throw new Error(`[uniweb] sort: "${text}" — direction must be \`asc\` or \`desc\`, not "${dir}".`)
+  }
+  return { field, desc: lower === 'desc' }
+}
+
+/**
+ * The door's spelling of a sort: `date` ascending, `-date` descending.
+ *
+ * @param {string|{field:string, desc?:boolean}|null|undefined} sort
+ * @returns {string|null}
+ */
+export function sortToWire(sort) {
+  const spec = parseSort(sort)
+  if (!spec) return null
+  return spec.desc ? `-${spec.field}` : spec.field
+}
+
+/**
+ * Sort records by one key. Returns a new array; the input is not mutated.
+ *
+ * Strings compare with `localeCompare` so `apple` sorts before `Banana`; anything
+ * else compares with `<`/`>`, which is right for numbers and ISO date strings. A
+ * record with no value for the key sorts as the empty string — first ascending,
+ * last descending — which is what every previous evaluator did.
+ *
+ * @param {Array<Object>} items
+ * @param {string|{field:string, desc?:boolean}|null|undefined} sort
+ * @returns {Array<Object>}
+ */
+export function sortRecords(items, sort) {
+  const spec = parseSort(sort)
+  if (!spec || !Array.isArray(items) || items.length === 0) return items
+  const { field, desc } = spec
+  return [...items].sort((a, b) => {
+    const av = readPath(a, field) ?? ''
+    const bv = readPath(b, field) ?? ''
+    const cmp = typeof av === 'string' && typeof bv === 'string'
+      ? av.localeCompare(bv)
+      : (av > bv ? 1 : av < bv ? -1 : 0)
+    return desc ? -cmp : cmp
+  })
+}
+
+function readPath(record, path) {
+  if (!record || typeof record !== 'object') return undefined
+  if (path.indexOf('.') === -1) return record[path]
+  let cursor = record
+  for (const segment of path.split('.')) {
+    if (cursor == null || typeof cursor !== 'object') return undefined
+    cursor = cursor[segment]
+  }
+  return cursor
+}

package/src/website.js

@@ -11,7 +11,9 @@ 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 } from './route-match.js'
+import { matchDynamicRoute, decodeRouteValue, routePatternToRegex, splitPathCapture } from './route-match.js'
+import { resolveFetchConfigs } from './fetch-config.js'
+import { buildDetailConfig } from './detail-url.js'
 import { resolveService } from './services.js'
 
 /**
@@ -57,7 +59,7 @@ export default class Website {
       transport,
       dev,
     })
-    this.entityStore = new EntityStore({ website: this })
+    this.entityStore = new EntityStore({ website: this, dev })
 
     // Observable site-wide state — allocated on first access via the `state`
     // getter, survives content rebuilds. Read-only prop (no `website.state = X`
@@ -558,14 +560,36 @@ export default class Website {
     pageData.route = concreteRoute
     pageData.isDynamic = false // No longer a template
 
-    const paramName = Object.keys(params)[0]
-    const paramValue = Object.values(params)[0]
+    // ⭐ 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
     pageData.dynamicContext = {
       templateRoute: templatePage.route,
-      params,
+      params: variables,
       paramName,
       paramValue,
       schema: pluralSchema,
@@ -580,27 +604,62 @@ 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
-    const parentRoute = templatePage.route.replace(/\/:[\w]+$/, '') || '/'
+    // 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)
 
     if (parentPage && pluralSchema) {
-      // Find the records from the parent's fetch config via the dispatcher's
-      // peek (sync cache probe). Used to populate the page title / notFound
-      // flag on dynamic pages before the page instance is constructed.
+      // 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.
+      //
+      // ⛔ RESOLVED THE WAY THE ENTITY STORE RESOLVES IT, not the raw declaration.
+      // Until 2026-09-04 this peeked `parentPage.fetch` as authored — `{ query,
+      // path, as }` — while the store writes under the RESOLVED config: on a live
+      // lane that carries `endpoint` and no `path`, and on a non-default locale a
+      // `/fr/data/…` path. Two different keys for one dataset, so the probe
+      // 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) {
-        const fetchConfig = Array.isArray(parentFetch)
-          ? parentFetch.find(f => f.schema === pluralSchema)
-          : (parentFetch.schema === pluralSchema ? parentFetch : null)
+        // ⛔ `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,
+          records: this.config?.records ?? null,
+          variables,
+        }).get(pluralSchema)
         if (fetchConfig) {
-          const cached = this.fetcher.peek(fetchConfig, { website: this })
+          const ctx = { website: this }
+          // ⭐ The page is about ONE record, so ask for that record first: a
+          // cached detail fetch (a live lane's record address, a deferred
+          // query's per-record file) carries the title even when the list was
+          // never fetched — a cold load on a detail URL — where a scan of the
+          // list finds nothing and silently sets no title (F3, 2026-09-04).
+          const detailCfg = fetchConfig.detail
+            ? buildDetailConfig(fetchConfig, { paramName, paramValue })
+            : null
+          const detailCached = detailCfg ? this.fetcher.peek(detailCfg, ctx) : null
+          const record = detailCached?.data
+          if (record && typeof record === 'object' && !Array.isArray(record)) currentItem = record
+
+          const cached = this.fetcher.peek(fetchConfig, ctx)
           items = Array.isArray(cached?.data) ? cached.data : []
         }
       }
 
-      const currentItem = items.find(item => String(item[paramName]) === String(paramValue))
+      if (!currentItem) {
+        currentItem = items.find(item => String(item[paramName]) === String(paramValue)) ?? null
+      }
 
       if (currentItem) {
         if (currentItem.title) pageData.title = currentItem.title
@@ -619,7 +678,7 @@ export default class Website {
       // { 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.
-      pageData._recordsLoaded = items.length > 0
+      pageData._recordsLoaded = items.length > 0 || currentItem !== null
     }
 
     // Create the page instance
@@ -809,6 +868,31 @@ export default class Website {
     return resolvedHref
   }
 
+  /**
+   * 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.
+   *
+   * ⭐ This is how a caller outside a template 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.
+   *
+   * @param {string} key - a binding key (`content.data.<key>`)
+   * @returns {{ route: string, paramName: string } | null}
+   */
+  detailTemplateFor(key) {
+    if (!key) return null
+    for (const data of this._dynamicPageData.values()) {
+      if (data?.parentSchema === key && data.paramName) {
+        return { route: data.route, paramName: data.paramName }
+      }
+    }
+    return null
+  }
+
   /**
    * Resolve a `page:<stable_id>` detail-page reference (from a fetch config's
    * `detailPage`) to a locale-specific route TEMPLATE, e.g. '/blog/:slug'. The