@uniweb/core 0.20.0 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
@@ -44,8 +44,8 @@
     "vitest": "^4.1.7"
   },
   "dependencies": {
-    "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/theming": "^0.1.15"
+    "@uniweb/theming": "^0.1.15",
+    "@uniweb/semantic-parser": "^1.4.0"
   },
   "scripts": {
     "test": "vitest run"

package/src/datastore.js

@@ -21,7 +21,7 @@
  *
  * ⭐ TWO IDENTITIES, decided by whether the request carries an ADDRESS.
  *
- * An ADDRESSED request — `path`, `url` or `endpoint` — is identified by where it
+ * 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`
@@ -37,8 +37,8 @@
  * (brief) and a record (full) of one query would collide — the one defect on
  * this path that delivers WRONG data rather than none.
  *
- * `locale` is hashed on both when present: a live lane's address does not carry
- * the locale, and two locales' records must not share an entry (F1).
+ * `locale` is hashed on both when present: two locales' answers must not share
+ * an entry, and a door config always carries the locale it was asked in.
  *
  * @param {Object} request - Normalized request (or fetch config)
  * @returns {string} A stable JSON string usable as a cache-Map key
@@ -47,18 +47,18 @@ export function deriveCacheKey(request) {
   // ⭐ `as` is the binding key — the name it has had since 2026-09-02, when the
   // compatibility alias for the older `schema` spelling was removed alongside
   // frontend's and hosting's.
-  const { path, url, endpoint, transform, locale } = request || {}
+  const { path, url, transform, locale } = request || {}
   const as = request?.as
   const method = request?.method && request.method.toUpperCase() !== 'GET'
     ? request.method.toUpperCase()
     : undefined
   const body = method === 'POST' ? request?.body : undefined
-  if (path || url || endpoint) {
+  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, endpoint, as, transform, method, body, locale })
+    return JSON.stringify({ path, url, as, transform, method, body, locale })
   }
   const { query, schema, scope, where, sort, limit, depth } = request || {}
   return JSON.stringify({ query, schema, scope, where, sort, limit, depth, as, transform, locale })

package/src/detail-url.js

@@ -22,6 +22,7 @@
  * a matched route pattern says nothing about the record behind it.
  */
 
+import { recordHandle } from './route-match.js'
 import { substitutePlaceholders } from './substitute-placeholders.js'
 
 /**
@@ -54,8 +55,9 @@ function paramContext(paramName, paramValue, record) {
   // `useEntityDetail` — its slug fills the name the FILE was written under. A
   // caller with no record in hand leaves `{slug}` literal rather than guessing
   // the capture is one: a visibly unresolved address beats a plausible wrong one.
-  if (paramName !== 'slug' && record && typeof record === 'object' && record.slug != null && record.slug !== '') {
-    context.slug = record.slug
+  const handle = recordHandle(record)
+  if (paramName !== 'slug' && handle != null && handle !== '') {
+    context.slug = handle
   }
   return context
 }
@@ -120,17 +122,12 @@ export function buildDetailConfig(queryConfig, dynamicContext) {
     }
   }
 
-  // Three address kinds now, and the detail request must come back as the SAME
-  // kind: an `endpoint` carries remote semantics the fetcher decides on, so
-  // returning a detail as `path` would silently drop operator pushdown and the
-  // site's static headers for exactly the request that is one record.
-  const baseUrl = queryConfig.endpoint || queryConfig.url || queryConfig.path
+  // 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`. (A third kind, the host's address door, was retired 2026-09-04.)
+  const baseUrl = queryConfig.url || queryConfig.path
   if (!baseUrl) return null
-  const addressKey = queryConfig.endpoint
-    ? 'endpoint'
-    : queryConfig.url
-      ? 'url'
-      : 'path'
+  const addressKey = queryConfig.url ? 'url' : 'path'
 
   // What every detail config carries beside its address:
   //   `as`             — the binding key, so the record lands where the list did;

package/src/entity-store.js

@@ -15,7 +15,7 @@
  */
 
 import { isFetchRefinement, resolveFetchConfigs } from './fetch-config.js'
-import { fillRoutePattern } from './route-match.js'
+import { fillRoutePattern, routeParamValue } from './route-match.js'
 import { sortRecords } from './sort.js'
 
 /**
@@ -252,7 +252,7 @@ export default class EntityStore {
           const { paramName, paramValue } = dynamicContext
           const items = cached.data
           let filtered = Array.isArray(items)
-            ? items.filter((item) => String(item[paramName]) !== String(paramValue))
+            ? items.filter((item) => String(routeParamValue(item, paramName)) !== String(paramValue))
             : items
           if (order) filtered = this._sortItems(filtered, order)
           data[schema] = limit && Array.isArray(filtered) ? filtered.slice(0, limit) : filtered
@@ -278,7 +278,7 @@ export default class EntityStore {
           const { paramName, paramValue } = dynamicContext
           const items = cached.data
           const match = Array.isArray(items)
-            ? items.find((item) => String(item[paramName]) === String(paramValue))
+            ? items.find((item) => String(routeParamValue(item, paramName)) === String(paramValue))
             : null
           if (!match) {
             data[schema] = []
@@ -386,7 +386,7 @@ export default class EntityStore {
         }
         const { paramName, paramValue } = dynamicContext
         let filtered = Array.isArray(records)
-          ? records.filter((item) => String(item[paramName]) !== String(paramValue))
+          ? records.filter((item) => String(routeParamValue(item, paramName)) !== String(paramValue))
           : (records ?? [])
         if (order) filtered = this._sortItems(filtered, order)
         data[schema] = limit && Array.isArray(filtered) ? filtered.slice(0, limit) : filtered
@@ -424,7 +424,7 @@ export default class EntityStore {
         }
 
         const match = records?.find(
-          (item) => String(item[paramName]) === String(paramValue)
+          (item) => String(routeParamValue(item, paramName)) === String(paramValue)
         ) ?? null
 
         if (!match) {

package/src/fetch-config.js

@@ -28,7 +28,7 @@
  */
 
 import { queryDataUrl, isDataUrl, recordDataUrl } from './data-paths.js'
-import { resolveQueryAddress, resolveRecordAddressPattern, resolveQueryDoor } from './query-address.js'
+import { resolveQueryDoor } from './query-address.js'
 
 /**
  * Is this fetch declaration a per-instance *refinement* of an ancestor's
@@ -104,24 +104,6 @@ function applyDeferredDetail(cfg, queries, records) {
   // every door config has a detail source; `buildDetailConfig` composes it.
   if (cfg.door) return { ...cfg, detail: true }
 
-  // ⭐ A lane's record address is injected whenever the lane declares one —
-  // NOT only for a `deferred:` query, and the difference is load-bearing.
-  //
-  // A live lane answers a list request at brief depth and a record request in
-  // full, so a detail page that filtered the list would render the brief and
-  // silently miss the body. And it cannot fall back to the rule below: the
-  // `deferred:` declaration lives in `config.queries`, which a host's
-  // projection is not obliged to carry — so on such a host that rule can never
-  // fire, and this is the only way a detail page reaches a whole record.
-  if (cfg.endpoint) {
-    // ⛔ `cfg.query`, not `cfg.query ?? cfg.schema`. The `??` was unreachable:
-    // `endpoint` is set in exactly one place (`resolveQuerySource`), which returns
-    // early unless `cfg.query` is a non-empty string — so reaching here proves it.
-    // It read as a tolerance for two producer shapes and was really a vestige of
-    // the build lane not emitting `query`, which it now does.
-    const recordPattern = resolveRecordAddressPattern(cfg.query, records)
-    if (recordPattern) return { ...cfg, detail: recordPattern }
-  }
 
   // ⛔ **`config.queries` is keyed by QUERY NAME, so look it up by the query.**
   // This read `cfg.schema` — the BINDING KEY, which merely defaults to the query
@@ -159,10 +141,15 @@ function applyDeferredDetail(cfg, queries, records) {
  * The author names a query; this decides where its records live, and there are
  * exactly two answers:
  *
- *   - a host declared a live lane (`config.records`) → an `endpoint`, final on
- *     arrival, which the fetcher calls without composing anything further;
+ *   - a host declared a question door (`config.records.query`) → a `door`, and
+ *     the whole query goes to it (`schema` from the payload's `config.queries`;
+ *     a door with no Model ref is a loud per-key error, never a fallthrough);
  *   - nobody did → the `path` of the artifact the build emitted.
  *
+ * ⛔ There is no third answer. The ADDRESS door — `config.records.list` /
+ * `.record`, a GET lane the runtime evaluated the query over locally — was
+ * retired 2026-09-04 by ruling (`query-address.js` says why).
+ *
  * ⭐ The second is not a fallback in the apologetic sense. It is the answer for
  * every site with no backend, which is the framework's default rather than a
  * degraded mode — so an absent lane is silent, not warned.
@@ -188,24 +175,24 @@ function resolveQuerySource(cfg, records, { queries = null, locale = null, defau
   if (door) {
     const decl = queries && typeof queries === 'object' ? queries[cfg.query] : null
     const schema = typeof decl?.schema === 'string' && decl.schema ? decl.schema : null
-    if (schema) {
-      const { path, url, ...rest } = cfg
-      const asked = { ...rest, door, schema }
-      // A saved query's own narrowing applies unless the fetch overrides it.
-      if (asked.scope === undefined && typeof decl.scope === 'string') asked.scope = decl.scope
-      if (asked.where === undefined && decl.where && typeof decl.where === 'object') asked.where = decl.where
-      if (asked.sort === undefined && decl.sort !== undefined && decl.sort !== null) asked.sort = decl.sort
-      if (asked.limit === undefined && typeof decl.limit === 'number' && decl.limit > 0) asked.limit = decl.limit
-      return asked
-    }
-  }
-
-  const endpoint = resolveQueryAddress(cfg.query, records)
-  if (endpoint) {
     // Drop the transitional `path`: two addresses on one request is an
     // ambiguity the fetcher would have to break by accident of field order.
     const { path, url, ...rest } = cfg
-    return { ...rest, endpoint }
+    if (!schema) {
+      // ⛔ LOUD, not a fallthrough. A payload that stamps a door and carries no
+      // Model ref for the query cannot ask, and reading the compiled file
+      // instead would turn a producer defect into a 404 that names the wrong
+      // thing. The fetcher refuses a door request with no `schema` before any
+      // request is made, and the block's `dataError` says exactly this.
+      return { ...rest, door, schema: null }
+    }
+    const asked = { ...rest, door, schema }
+    // A saved query's own narrowing applies unless the fetch overrides it.
+    if (asked.scope === undefined && typeof decl.scope === 'string') asked.scope = decl.scope
+    if (asked.where === undefined && decl.where && typeof decl.where === 'object') asked.where = decl.where
+    if (asked.sort === undefined && decl.sort !== undefined && decl.sort !== null) asked.sort = decl.sort
+    if (asked.limit === undefined && typeof decl.limit === 'number' && decl.limit > 0) asked.limit = decl.limit
+    return asked
   }
   return { ...cfg, path: queryDataUrl(cfg.query) }
 }
@@ -413,19 +400,15 @@ function foldScope(cfg) {
  * query's compiled file is the stripped list. `full` otherwise. An explicit
  * `depth` on the config wins (a question door's client sets it).
  *
- * `locale` — stamped on a LIVE-lane config only. A compiled path already carries
- * its locale (`/fr/data/…`), but a live address does not, and two locales'
- * records must not share a cache entry (F1). Absent on the default locale, so a
- * site with one language sees no new field.
+ * `locale` — stamped on a DOOR config only. A compiled path already carries its
+ * locale (`/fr/data/…`); a door is asked in one locale (it is in the route), and
+ * two locales' answers must not share a cache entry.
  */
 function stampDepthAndLocale(cfg, locale, defaultLocale) {
   let out = cfg
   if (out.depth !== 'brief' && out.depth !== 'full') {
     out = { ...out, depth: out.detail ? 'brief' : 'full' }
   }
-  if (out.endpoint && locale && locale !== defaultLocale && out.locale === undefined) {
-    out = { ...out, locale }
-  }
   // A door is asked in exactly one locale — it is in the route — so the config
   // carries it whatever the locale is; two locales' answers never share an entry.
   if (out.door && out.locale === undefined) {

package/src/index.js

@@ -20,15 +20,10 @@ export { default as ObservableState } from './observable-state.js'
 
 // Utilities
 export { substitutePlaceholders } from './substitute-placeholders.js'
-// ⛔ `resolveQueryAddress` / `resolveRecordAddressPattern` are NOT re-exported
-// here. They are read by `./fetch-config.js` and by nothing else in any repo
-// (measured 2026-09-01 over every .js/.jsx/.mjs/.ts/.tsx file in the
-// workspace). A consumer that needs them imports `@uniweb/core/query-address`,
-// which is a declared subpath and a zero-dependency leaf — the same reach
-// `route-match` and `section-id` already have. Re-exporting an internal from
-// the package entry is not free: the import-map bridge enumerates this file's
-// surface and emits a live named re-export for every one, so nothing here can
-// ever be tree-shaken on the hosted lane.
+// `resolveQueryDoor` / `QUERY_DOOR_KEY` are NOT re-exported here: `./fetch-config.js`
+// reads them and a consumer that needs them imports `@uniweb/core/query-address`.
+// (The address door's `resolveQueryAddress` / `resolveRecordAddressPattern` were
+// deleted 2026-09-04 with the lane they addressed.)
 export { resolveFetchConfigs } from './fetch-config.js'
 export { buildDetailConfig, ROUTE_HANDLE_KEY } from './detail-url.js'
 // `isWildcardLanguages` is likewise internal — `./locale-config.js` reads it
@@ -52,7 +47,7 @@ export { evaluate as evaluateWhere, match as matchWhere } from './where.js'
 // (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 { fillRoutePattern, splitPathCapture, joinPathCapture, recordHandle, routeParamValue } 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/query-address.js

@@ -1,14 +1,16 @@
 /**
- * Resolve a query request to an address the fetcher can call.
+ * Resolve a query request to the one address a host can declare for it.
  *
  * ## The one idea
  *
- * A site names a query; it never names where its records live. Where
- * it lives is a **deployment** fact, and the two possible answers have different
- * owners:
+ * A site names a query; it never names where its records live. Where they live
+ * is a **deployment** fact, and the two possible answers have different owners:
  *
- *   1. **A host that serves records live** declares a pair of URL *patterns*
- *      at `config.records`. It owns every segment of them.
+ *   1. **A host that answers questions** declares a QUESTION DOOR at
+ *      `config.records.query` — a POST address with a `{locale}` slot. It owns
+ *      every segment of it; the runtime substitutes the one slot and sends the
+ *      whole query. ⛔ The question is composed elsewhere (`fetch-config.js`);
+ *      this file only says where it goes.
  *   2. **Nobody** — and the answer is the artifact the build itself emitted,
  *      `/data/<name>.json`, which is not an address at all but a path in the
  *      site's own URL space.
@@ -20,40 +22,34 @@
  * nothing, which is right for `submit` and wrong here, where the fallback is a
  * file the build knows it wrote.
  *
- * ## ⛔ Patterns, not a base — and the reason is a deleted function
+ * ## ⛔ The ADDRESS door is retired (2026-09-04) — do not bring it back
  *
- * A base assumes the layout is "root plus one segment". A pattern assumes
- * nothing, so a host can carry a site id, a locale segment, a different root
- * for records than for the list, or none of those, and move any of it
- * without a framework release.
+ * Until that day this file also read two URL PATTERNS off the same stamp —
+ * `list` (`{path}`) and `record` (`{param}`) — for a GET lane the runtime
+ * evaluated the query over locally. It went by ruling, with no hosted site to
+ * protect: two lanes on one host answered one query two ways (an operator the
+ * door refuses was honoured locally on the GET lane), the precedence between
+ * them was where the failure lived, and the address was composed from the
+ * query's NAME, which is not a folder path. A query is a question; a host that
+ * cannot answer one is a host with no records lane, and its site reads the
+ * compiled file. A host's `list` / `record` / `envelope` stamps are not read.
  *
- * This is the `config.assets.url` rule applied to records. That pattern exists
- * because the CLI once composed `{assetBase}dist/{id}/base.{ext}` — a backend's
- * path layout, inside a published CLI, on a release cadence the backend could
- * not move. It was deleted rather than parameterized. Composing a segment of
- * our own here would rebuild exactly that coupling, on a lane where the wrong
- * answer is *stale or missing content* rather than a visible 404.
+ * ## ⛔ A pattern, not a base — and the reason is a deleted function
  *
- * ⇒ Substituting `{path}` and `{param}` is the WHOLE of what this does.
+ * A base assumes the layout is "root plus one segment". A pattern assumes
+ * nothing, so a host can carry a site id, a locale segment, a different root
+ * for the door than for the site, or none of those, and move any of it
+ * without a framework release. This is the `config.assets.url` rule applied to
+ * records: the CLI once composed `{assetBase}dist/{id}/base.{ext}` — a backend's
+ * path layout, inside a published CLI — and it was deleted rather than
+ * parameterized. Substituting `{locale}` is the WHOLE of what this does.
  *
- * Zero-dependency beyond two sibling leaves, so the SSR pipeline and a Worker
+ * Zero-dependency beyond one sibling leaf, so the SSR pipeline and a Worker
  * isolate can both import it.
  */
 
 import { substitutePlaceholders } from './substitute-placeholders.js'
 
-/**
- * The placeholder a list pattern must carry.
- *
- * ⛔ IT IS `{path}`, NOT `{query}`, AND THAT IS NOT COSMETIC. A *query* is
- * framework's own build concept — a named set our build compiles to one file. A host
- * 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.
- */
-const PATH_SLOT = '{path}'
-/** The placeholder a record pattern must carry to address a specific record. */
-const PARAM_SLOT = '{param}'
 
 const warnedPatterns = new Set()
 
@@ -81,34 +77,6 @@ function readPattern(lane, key) {
   return typeof pattern === 'string' && pattern.length > 0 ? pattern : null
 }
 
-/**
- * The address for a whole query's records, or `null` to fall through to the artifact.
- *
- * ⚠️ A pattern that does not carry `{path}` is REFUSED rather than used.
- * Substituting nothing would yield one identical URL for every query on the
- * site — every schema reading the same records, with a 200 on each request. That
- * is the failure this check exists for; an unusable pattern must degrade to the
- * artifact, which is at least correct.
- *
- * @param {string} query - the query's authored name (the wiring key).
- * @param {Object|null} lane - `config.records`.
- * @returns {string|null} the address, or null when nothing usable is declared.
- */
-export function resolveQueryAddress(query, lane) {
-  if (typeof query !== 'string' || query.length === 0) return null
-  const pattern = readPattern(lane, 'list')
-  if (!pattern) return null
-  if (!pattern.includes(PATH_SLOT)) {
-    warnOnce(
-      `list:${pattern}`,
-      `config.records.list carries no ${PATH_SLOT} placeholder, so every ` +
-        `query would resolve to the same address. Ignoring it and reading the ` +
-        `compiled file instead.`
-    )
-    return null
-  }
-  return substitutePlaceholders(pattern, { path: query })
-}
 
 /**
  * The QUESTION door a host declares — a POST address with a `{locale}` slot —
@@ -144,33 +112,3 @@ export function resolveQueryDoor(lane, locale) {
   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.
- *
- * Returning a pattern rather than a finished URL is deliberate: the route param
- * is not known here, and the framework already has one place that resolves it
- * (`buildDetailConfig` / `substitutePlaceholders` at fetch time). Resolving it
- * twice, in two places, is how the two copies drift.
- *
- * @param {string} query
- * @param {Object|null} lane - `config.records`.
- * @returns {string|null} a pattern still containing `{param}`, or null.
- */
-export function resolveRecordAddressPattern(query, lane) {
-  if (typeof query !== 'string' || query.length === 0) return null
-  const pattern = readPattern(lane, 'record')
-  if (!pattern) return null
-  if (!pattern.includes(PARAM_SLOT)) {
-    warnOnce(
-      `record:${pattern}`,
-      `config.records.record carries no ${PARAM_SLOT} placeholder, so every record ` +
-        `would resolve to the same address. Ignoring it and reading the per-record ` +
-        `file instead.`
-    )
-    return null
-  }
-  // Only `{path}` is substituted here — `{param}` survives for the
-  // dynamic-route resolution that owns it.
-  return substitutePlaceholders(pattern, { path: query })
-}

package/src/route-match.js

@@ -238,6 +238,48 @@ export function joinPathCapture({ dir, slug } = {}) {
   return d ? `${d}/${slug}` : String(slug)
 }
 
+/**
+ * A record's PLACEMENT HANDLE — the segment its folder entry is named by, which is
+ * what a `[slug]` route (or the last segment of a `[...path]` one) matches.
+ *
+ * ⭐ Two lanes spell it differently and mean one thing. A host's records door
+ * serves the entry's handle as `$name` — `$`-namespaced because a Model may
+ * declare its own `name` or `slug` field (five of eight seeded briefs do), and
+ * the placement must not be shadowed by one. The file lane derives it from the
+ * source filename and calls it `slug`. `$name` wins when present: on a live
+ * record a Model field named `slug` is the author's data, not the placement.
+ *
+ * @param {Object} record
+ * @returns {string|undefined}
+ */
+export function recordHandle(record) {
+  if (!record || typeof record !== 'object') return undefined
+  const name = record.$name
+  if (typeof name === 'string' && name.length) return name
+  return record.slug
+}
+
+/**
+ * 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.
+ *
+ * ⛔ 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.
+ *
+ * @param {Object} record
+ * @param {string} paramName
+ * @returns {*}
+ */
+export function routeParamValue(record, paramName) {
+  if (!record || typeof record !== 'object') return undefined
+  if (paramName === 'slug') return recordHandle(record)
+  return record[paramName]
+}
+
 /**
  * Fill a route pattern's params from a record — the ONE encoder for a record's href.
  *
@@ -274,16 +316,17 @@ export function fillRoutePattern(pattern, values) {
     // 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 handle = recordHandle(values)
+    if (joinPathCapture({ dir: values.dir ?? values.path, slug: handle }) === 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)))
+    segments.push(encodeURIComponent(String(handle)))
     tailHref = '/' + segments.join('/')
     head = pattern.slice(0, tail.index)
   }
   const href = head.replace(new RegExp(`:(${PARAM_NAME})`, 'g'), (_, name) => {
-    const value = values[name]
+    const value = routeParamValue(values, name)
     if (value === undefined || value === null || value === '') {
       missing = true
       return ''

package/src/website.js

@@ -11,7 +11,7 @@ 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 } from './route-match.js'
+import { matchDynamicRoute, decodeRouteValue, routePatternToRegex, splitPathCapture, routeParamValue } from './route-match.js'
 import { resolveFetchConfigs } from './fetch-config.js'
 import { buildDetailConfig } from './detail-url.js'
 import { resolveService } from './services.js'
@@ -615,8 +615,8 @@ export default class Website {
       //
       // ⛔ 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
+      // path, as }` — while the store writes under the RESOLVED config: on a door
+      // lane that carries `door` 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
@@ -649,8 +649,11 @@ export default class Website {
             ? 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
+          // A door answers the record question as a list of one (a question's
+          // answer is always a list); a per-record file answers the bare record.
+          const raw = detailCached?.data
+          const record = Array.isArray(raw) ? raw[0] : raw
+          if (record && typeof record === 'object') currentItem = record
 
           const cached = this.fetcher.peek(fetchConfig, ctx)
           items = Array.isArray(cached?.data) ? cached.data : []
@@ -658,7 +661,7 @@ export default class Website {
       }
 
       if (!currentItem) {
-        currentItem = items.find(item => String(item[paramName]) === String(paramValue)) ?? null
+        currentItem = items.find(item => String(routeParamValue(item, paramName)) === String(paramValue)) ?? null
       }
 
       if (currentItem) {