@uniweb/core 0.21.0 → 0.22.0

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@uniweb/core",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
     ".": "./src/index.js",
     "./base-path": "./src/base-path.js",
-    "./collection-address": "./src/query-address.js",
-    "./query-address": "./src/query-address.js",
+    "./records-service": "./src/records-service.js",
     "./data-paths": "./src/data-paths.js",
     "./datastore": "./src/datastore.js",
     "./detail-url": "./src/detail-url.js",
@@ -44,8 +43,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

@@ -30,15 +30,15 @@
  * asking for `{ path, as }` must hit the entry the page's declaration filled —
  * that shared cache is a documented property of `useFetched`.
  *
- * An ADDRESS-LESS request — a QUESTION sent to a records door — is identified by
- * the question: `query`, `schema`, `scope`, `where`, `sort`, `limit`, `depth`.
+ * 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
  * 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.
  *
  * `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.
+ * an entry, and an asked 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

package/src/detail-url.js

@@ -91,12 +91,12 @@ function paramContext(paramName, paramValue, record) {
  */
 /**
  * The key a route param narrows a QUESTION by — the entry's own handle, which
- * a records door guarantees unique among siblings (the records door's contract
+ * 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 door 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 or the address door,
- * which narrow by the route's own param (`item[paramName]`).
+ * → `$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]`).
  */
 export const ROUTE_HANDLE_KEY = '$name'
 
@@ -106,13 +106,13 @@ export function buildDetailConfig(queryConfig, dynamicContext) {
   const { paramName, paramValue, record = null } = dynamicContext
   if (!paramName || paramValue === undefined) return null
 
-  // ⭐ A QUESTION DOOR: 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 door's 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.
-  if (queryConfig.door) {
+  // ⭐ 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.
+  if (queryConfig.ask) {
     const { sort, limit, detail: _detail, ...rest } = queryConfig
     return {
       ...rest,
@@ -124,14 +124,14 @@ export function buildDetailConfig(queryConfig, dynamicContext) {
 
   // Two address kinds, and the detail request comes back as the SAME kind as
   // the list: a `url` the author wrote stays a `url`, a compiled `path` stays a
-  // `path`. (A third kind, the host's address door, was retired 2026-09-04.)
+  // `path`.
   const baseUrl = queryConfig.url || queryConfig.path
   if (!baseUrl) return null
   const addressKey = queryConfig.url ? 'url' : 'path'
 
   // What every detail config carries beside its address:
   //   `as`             — the binding key, so the record lands where the list did;
-  //   `query`          — the query it is one record of (identity on a door);
+  //   `query`          — the query it is one record of (identity when asked);
   //   `depth: 'full'`  — what it asks for, and what the record index files it as;
   //   `dynamicContext` — the route param, which the default fetcher already keys
   //                      a SINGLE-RECORD response on (`envelope.item`, body

package/src/entity-store.js

@@ -152,10 +152,11 @@ export default class EntityStore {
         // after the payload key was renamed — a dead option name, silently: the
         // resolver simply saw no queries and stopped injecting `detail:`.
         queries: website?.config?.queries ?? null,
-        // A host's live-records lane. Absent on every static site and on
-        // local dev, which is why `resolveQuerySource` treats absence as
-        // the ordinary case and reads the compiled artifact without comment.
-        records: website?.config?.records ?? null,
+        // The host's services; its `records` row is the live-records lane.
+        // Absent on every static site and on local dev, which is why
+        // `resolveQuerySource` treats absence as the ordinary case and reads
+        // the compiled artifact without comment.
+        services: website?.config?.services ?? null,
         variables,
       },
     )
@@ -259,8 +260,8 @@ export default class EntityStore {
         } else {
           allCached = false
         }
-      } else if (isRouteQuery && cfg.door) {
-        // A question door: the record's own answer is cached under its own key.
+      } else if (isRouteQuery && cfg.ask) {
+        // The records service: the record's own answer is cached under its own key.
         const detailCfg = this._buildDetailConfig(cfg, dynamicContext)
         const detailCached = detailCfg ? dispatcher?.peek(detailCfg, ctx) : null
         if (detailCached) {
@@ -390,8 +391,8 @@ export default class EntityStore {
           : (records ?? [])
         if (order) filtered = this._sortItems(filtered, order)
         data[schema] = limit && Array.isArray(filtered) ? filtered.slice(0, limit) : filtered
-      } else if (isRouteQuery && cfg.door) {
-        // ⭐ A QUESTION DOOR needs no list to find the record: the record is the
+      } else if (isRouteQuery && cfg.ask) {
+        // ⭐ THE RECORDS SERVICE needs no list to find the record: the record is the
         // same question narrowed by the route's handle, so list and record are
         // asked together — one round trip, and no client-side scan gating the
         // fetch (F13, the live half). The list is asked too, because sections

package/src/fetch-config.js

@@ -14,12 +14,30 @@
  *
  * INTENTIONALLY A LEAF: safe to load anywhere — including environments with no
  * DOM, no filesystem, and a hard bundle-size ceiling. The rule that protects
- * that is **no transitive graph**: import nothing from the package root (which
- * pulls semantic-parser and theming) and nothing that itself imports. A
- * zero-dependency sibling leaf is admissible and `./data-paths.js` is the only
- * one taken — the path convention it holds has to be identical here and in the
- * build that emits the files, and a second copy of that string is precisely
- * the drift this module exists to prevent.
+ * that is **import nothing from the package root** (which pulls semantic-parser
+ * and theming) and nothing that reaches it transitively.
+ *
+ * ⚠️ **This said "and nothing that itself imports — `./data-paths.js` is the
+ * only one taken", and both halves had stopped being true.** `query-address.js`
+ * was added as an import and itself imports; on 2026-09-06 it became
+ * `records-service.js` and the chain grew again. **The admissible set, named
+ * rather than counted:**
+ *
+ *     fetch-config → data-paths                                    (leaf)
+ *                  → records-service → substitute-placeholders     (leaf)
+ *                                    → services → base-path        (leaf)
+ *
+ * Every module in it is pure JS with no `node:*`, no DOM and no package-root
+ * import — the property that actually matters. "Depth 1" was a proxy for it
+ * that stopped holding without anything failing, which is why the rule is now
+ * stated as the property.
+ *
+ * ⛔ **Two edges are deliberate and must not be inlined**, for one reason:
+ * `data-paths.js` holds the `/data/<name>.json` convention, which has to be
+ * identical here and in the build that emits the files; `services.js` holds
+ * `readEndpoint`, the ONE rule for reading a service declaration. A second copy
+ * of either is precisely the drift this module exists to prevent. ⇒ **If you
+ * add an edge, say here why it holds.**
  *
  * 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
@@ -28,7 +46,7 @@
  */
 
 import { queryDataUrl, isDataUrl, recordDataUrl } from './data-paths.js'
-import { resolveQueryDoor } from './query-address.js'
+import { resolveRecordsService } from './records-service.js'
 
 /**
  * Is this fetch declaration a per-instance *refinement* of an ancestor's
@@ -97,12 +115,12 @@ function localizeConfig(cfg, locale, defaultLocale) {
  * @param {Object|null} queries - the site's `config.queries` map
  * @returns {Object} the original config, or a copy carrying `detail`
  */
-function applyDeferredDetail(cfg, queries, records) {
+function applyDeferredDetail(cfg, queries) {
   if (cfg.detail !== undefined) return cfg
 
-  // A question door answers a RECORD by the same question narrowed to it, so
-  // every door config has a detail source; `buildDetailConfig` composes it.
-  if (cfg.door) return { ...cfg, detail: true }
+  // The records service answers a RECORD by the same question narrowed to it,
+  // so every asked config has a detail source; `buildDetailConfig` composes it.
+  if (cfg.ask) return { ...cfg, detail: true }
 
 
   // ⛔ **`config.queries` is keyed by QUERY NAME, so look it up by the query.**
@@ -141,14 +159,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 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.
+ *   - a host offers the `records` service (`config.services.records`) → an
+ *     `ask` address, and the whole query goes to it (`schema` from the
+ *     payload's `config.queries`; an `ask` with no Model ref is a loud per-key
+ *     error, never a fallthrough);
+ *   - nobody does → 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).
+ * ⛔ There is no third answer, and there has not been one since the GET lane
+ * the runtime evaluated locally was retired (2026-09-04). `records-service.js`
+ * says why the wrapper it lived in went with it.
  *
  * ⭐ 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
@@ -161,32 +180,31 @@ function applyDeferredDetail(cfg, queries, records) {
  * `query`, ignoring any `path`), so the two agree rather than disagreeing on a
  * shape nobody hand-writes.
  */
-function resolveQuerySource(cfg, records, { queries = null, locale = null, defaultLocale = null } = {}) {
+function resolveQuerySource(cfg, services, { queries = null, locale = null, defaultLocale = null } = {}) {
   if (typeof cfg.query !== 'string' || cfg.query.length === 0) return cfg
 
-  // ⭐ THE QUESTION DOOR FIRST. A host that answers questions gets the whole
-  // query — `schema`, `scope`, `where`, `sort`, `limit`, `depth` — and composes
-  // no per-query address at all (the records door's contract, §2). It
-  // needs the query's MODEL REF, which lives on the site's `config.queries`
-  // declaration; a payload that carries the door but not the declaration
-  // cannot ask, and falls through to the address door below. ⚠️ Dark until a
-  // host stamps the door; see `resolveQueryDoor`.
-  const door = resolveQueryDoor(records, locale ?? defaultLocale)
-  if (door) {
+  // ⭐ THE SERVICE FIRST. A host that answers questions gets the whole query —
+  // `schema`, `scope`, `where`, `sort`, `limit`, `depth` — and composes no
+  // per-query address at all (the records contract, §2). It needs the query's
+  // MODEL REF, which lives on the site's `config.queries` declaration; a
+  // payload that offers the service but carries no declaration cannot ask, and
+  // 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.
     const { path, url, ...rest } = cfg
     if (!schema) {
-      // ⛔ LOUD, not a fallthrough. A payload that stamps a door and carries no
+      // ⛔ LOUD, not a fallthrough. A payload that offers the service 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
+      // thing. The fetcher refuses an asked request with no `schema` before any
       // request is made, and the block's `dataError` says exactly this.
-      return { ...rest, door, schema: null }
+      return { ...rest, ask, schema: null }
     }
-    const asked = { ...rest, door, schema }
+    const asked = { ...rest, ask, 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
@@ -248,9 +266,9 @@ function bindingKey(cfg) {
  * @param {string|null} [options.locale] - the locale being rendered
  * @param {string|null} [options.defaultLocale] - the site's default locale
  * @param {Object|null} [options.queries] - the site's `config.queries`
- * @param {Object|null} [options.records] - the site's `config.records`, 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.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
@@ -263,7 +281,7 @@ export function resolveFetchConfigs(sources, options = {}) {
     locale = null,
     defaultLocale = null,
     queries = null,
-    records = null,
+    services = null,
     variables = null,
   } = options
 
@@ -280,10 +298,10 @@ export function resolveFetchConfigs(sources, options = {}) {
       if (!collectAll && !schemas.includes(key)) continue
       // Address first: localization and deferred-detail both key on `path`,
       // which a query ref does not have until this runs.
-      const sourced = resolveQuerySource(cfg, records, { queries, locale, defaultLocale })
+      const sourced = resolveQuerySource(cfg, services, { queries, locale, defaultLocale })
       const localized = localizeConfig(sourced, locale, defaultLocale)
       const bound = foldScope(bindRouteVariables(localized, variables))
-      configs.set(key, stampDepthAndLocale(applyDeferredDetail(bound, queries, records), locale, defaultLocale))
+      configs.set(key, stampDepthAndLocale(applyDeferredDetail(bound, queries), locale, defaultLocale))
     }
   }
 
@@ -305,8 +323,8 @@ const ROUTE_VARIABLE = /^:(path|dir|slug)$/
  * 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. Backend's records door states the same
- * rule from its side (the records door's contract, §6b).
+ * bound, and binds the empty value. The backend answering the records service
+ * states the same rule from its side (the records contract, §6b).
  *
  * ⚠️ 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
@@ -372,17 +390,17 @@ function bindWhere(where, variables) {
 }
 
 /**
- * `scope:` on a lane that cannot be ASKED — the compiled file, an address door —
- * is the same question as `where: { path: { under: scope } }`: a record's
+ * `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 door that takes `scope` natively. A config addressed to a question door
- * (`door`) keeps `scope` as the door's own field.
+ * on a service that takes `scope` natively. A config carrying `ask` keeps
+ * `scope` as the service's own field.
  */
 function foldScope(cfg) {
-  if (typeof cfg.scope !== 'string' || cfg.scope === '' || cfg.door) return cfg
+  if (typeof cfg.scope !== 'string' || cfg.scope === '' || cfg.ask) return cfg
   const { scope, ...rest } = cfg
   const under = { path: { under: scope } }
   const where = cfg.where && typeof cfg.where === 'object' && Object.keys(cfg.where).length
@@ -398,20 +416,20 @@ function foldScope(cfg) {
  * a list with a separate record address is a list of partial records: a live
  * lane answers a list at brief depth and a record in full, and a `deferred:`
  * query's compiled file is the stripped list. `full` otherwise. An explicit
- * `depth` on the config wins (a question door's client sets it).
+ * `depth` on the config wins (the records service's client sets it).
  *
- * `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.
+ * `locale` — stamped on an ASKED config only. A compiled path already carries
+ * its locale (`/fr/data/…`); the service 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' }
   }
-  // A door is asked in exactly one locale — it is in the route — so the config
+  // The service 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) {
+  if (out.ask && out.locale === undefined) {
     const asked = locale ?? defaultLocale
     if (asked) out = { ...out, locale: asked }
   }

package/src/index.js

@@ -20,10 +20,8 @@ export { default as ObservableState } from './observable-state.js'
 
 // Utilities
 export { substitutePlaceholders } from './substitute-placeholders.js'
-// `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.)
+// `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 { buildDetailConfig, ROUTE_HANDLE_KEY } from './detail-url.js'
 // `isWildcardLanguages` is likewise internal — `./locale-config.js` reads it

package/src/records-service.js

@@ -0,0 +1,113 @@
+/**
+ * Where a site's queries are answered — the `records` service.
+ *
+ * ## The one idea
+ *
+ * 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 answers questions** offers the `records` service — an
+ *      address with a `{locale}` slot, which takes a POST carrying the whole
+ *      query. It owns every segment of it; the runtime substitutes the one slot
+ *      and sends the question. ⛔ 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.
+ *
+ * Absence of (1) is therefore not an error and not a decline: it falls THROUGH
+ * to (2). That is what makes a site with no backend the default rather than a
+ * special case.
+ *
+ * ## ⭐ It is a SERVICE, and that is the whole of its shape
+ *
+ * *[Diego, 2026-09-06: "`records` does sound like a service. It is the service
+ * of having a dynamic record provider."]* So it sits in `config.services`
+ * beside `search`, `submit` and `assistant`, is read with the same
+ * `readEndpoint` rule (string shorthand or `{ endpoint }`), and follows the
+ * same law: **presence is the switch.** A host that offers a records lane
+ * stamps the row; one that does not, does not.
+ *
+ * ⛔ **It did NOT used to be.** Until 2026-09-06 it was `config.records`, an
+ * object of its own whose only surviving key was `query` — a wrapper left over
+ * from the day there were two lanes to choose between. One host-stamped address
+ * read by two mechanisms was the accident; a service row is the shape it always
+ * had.
+ *
+ * ## ⛔ The HOST tier only — and the reason is mechanical, not a policy
+ *
+ * `resolveService` reads the site's authored tier first and the host's second.
+ * This does not, because it cannot: its caller `resolveFetchConfigs` is a leaf
+ * that runs in an SSR isolate over a plain content object with no `Website` to
+ * hand. It reads `config.services` directly, so the authored tier is not
+ * available here. ⇒ **A site does not declare its own record provider**, which
+ * is also the standing ruling — a third-party source is a foundation transport,
+ * not site-level config *(2026-09-04, the retired `fetcher:` vocabulary)*.
+ *
+ * ## ⛔ A pattern, not a base — and the reason is a deleted function
+ *
+ * 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 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
+ * isolate can both import it.
+ */
+
+import { substitutePlaceholders } from './substitute-placeholders.js'
+import { readEndpoint } from './services.js'
+
+const warnedPatterns = new Set()
+
+function warnOnce(key, message) {
+  if (warnedPatterns.has(key)) return
+  warnedPatterns.add(key)
+  console.warn(`[records-service] ${message}`)
+}
+
+/** Test seam — reset the once-per-pattern memo so suites do not leak. */
+export function _resetRecordsServiceWarnings() {
+  warnedPatterns.clear()
+}
+
+/**
+ * The service name a host stamps to say it answers queries.
+ *
+ * One constant, changed in one place should it ever move.
+ */
+export const RECORDS_SERVICE = 'records'
+
+/**
+ * The address a query is asked at, substituted for one locale, or `null` when
+ * no host offers the service.
+ *
+ * A row present with no address is a host saying "not for this site" —
+ * indistinguishable, for a caller, from no row at all. Both fall through to the
+ * compiled artifact.
+ *
+ * The locale is a ROUTE SEGMENT there, never a query param: a request that
+ * cannot name one does not address the service at all.
+ *
+ * @param {Object|null} services - `config.services`
+ * @param {string|null} locale - the locale being rendered; required
+ * @returns {string|null}
+ */
+export function resolveRecordsService(services, locale) {
+  if (!services || typeof services !== 'object' || Array.isArray(services)) return null
+  const endpoint = readEndpoint(services[RECORDS_SERVICE])
+  if (!endpoint) return null
+  if (typeof locale !== 'string' || locale.length === 0) return null
+  if (!endpoint.includes('{locale}')) {
+    warnOnce(
+      `records:${endpoint}`,
+      `config.services.${RECORDS_SERVICE} carries no {locale} placeholder; the service takes the ` +
+        `locale as a route segment. Ignoring it.`
+    )
+    return null
+  }
+  return substitutePlaceholders(endpoint, { locale })
+}

package/src/route-match.js

@@ -242,7 +242,7 @@ export function joinPathCapture({ dir, 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
+ * ⭐ Two lanes spell it differently and mean one thing. A host's records service
  * 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

package/src/services.js

@@ -96,7 +96,7 @@ const ABSOLUTE_URL_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i
  * @param {*} declaration
  * @returns {string} the endpoint, or '' when there is none
  */
-function readEndpoint(declaration) {
+export function readEndpoint(declaration) {
   if (typeof declaration === 'string') return declaration.trim()
   if (typeof declaration?.endpoint === 'string') return declaration.endpoint.trim()
   return ''

package/src/sort.js

@@ -7,11 +7,11 @@
  * 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
+ * been refused by the records service, 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
+ * Author spelling, unchanged: `date`, `date asc`, `date desc`. The records service'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.
  *
@@ -67,7 +67,7 @@ export function parseSort(sort) {
 }
 
 /**
- * The door's spelling of a sort: `date` ascending, `-date` descending.
+ * The service's spelling of a sort: `date` ascending, `-date` descending.
  *
  * @param {string|{field:string, desc?:boolean}|null|undefined} sort
  * @returns {string|null}

package/src/website.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 door
-      // lane that carries `door` and no `path`, and on a non-default locale a
+      // path, as }` — while the store writes under the RESOLVED config: on the
+      // asked lane that carries `ask` 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
@@ -635,7 +635,7 @@ export default class Website {
           locale: this.getActiveLocale(),
           defaultLocale: this.getDefaultLocale(),
           queries: this.config?.queries ?? null,
-          records: this.config?.records ?? null,
+          services: this.config?.services ?? null,
           variables,
         }).get(pluralSchema)
         if (fetchConfig) {
@@ -649,7 +649,7 @@ export default class Website {
             ? buildDetailConfig(fetchConfig, { paramName, paramValue })
             : null
           const detailCached = detailCfg ? this.fetcher.peek(detailCfg, ctx) : null
-          // A door answers the record question as a list of one (a question's
+          // The service 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

package/src/query-address.js

@@ -1,114 +0,0 @@
-/**
- * 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 they live
- * is a **deployment** fact, and the two possible answers have different owners:
- *
- *   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.
- *
- * Absence of (1) is therefore not an error and not a decline: it falls THROUGH
- * to (2). That is what makes a site with no backend the default rather than a
- * special case, and it is why this does not go through `resolveService` — a
- * service's absence means the site has no such feature and the caller draws
- * nothing, which is right for `submit` and wrong here, where the fallback is a
- * file the build knows it wrote.
- *
- * ## ⛔ The ADDRESS door is retired (2026-09-04) — do not bring it back
- *
- * 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.
- *
- * ## ⛔ A pattern, not a base — and the reason is a deleted function
- *
- * 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 one sibling leaf, so the SSR pipeline and a Worker
- * isolate can both import it.
- */
-
-import { substitutePlaceholders } from './substitute-placeholders.js'
-
-
-const warnedPatterns = new Set()
-
-function warnOnce(key, message) {
-  if (warnedPatterns.has(key)) return
-  warnedPatterns.add(key)
-  console.warn(`[query-address] ${message}`)
-}
-
-/** Test seam — reset the once-per-pattern memo so suites do not leak. */
-export function _resetQueryAddressWarnings() {
-  warnedPatterns.clear()
-}
-
-/**
- * Is this a usable lane declaration?
- *
- * A declaration present with no pattern is a host saying "not for this site" —
- * indistinguishable, for a caller, from no declaration at all. Both fall
- * through to the artifact.
- */
-function readPattern(lane, key) {
-  if (!lane || typeof lane !== 'object' || Array.isArray(lane)) return null
-  const pattern = lane[key]
-  return typeof pattern === 'string' && pattern.length > 0 ? pattern : null
-}
-
-
-/**
- * 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 })
-}
-