@uniweb/build 0.78.0 → 0.80.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.78.0",
+  "version": "0.80.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -57,15 +57,15 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
-    "@uniweb/projections": "^0.7.14",
-    "@uniweb/content-writer": "^0.3.4",
     "@uniweb/semantic-parser": "^1.5.1",
+    "@uniweb/projections": "^0.7.15",
+    "@uniweb/content-writer": "^0.3.4",
+    "@uniweb/schemas": "^0.13.0",
     "@uniweb/content-reader": "^1.2.8",
-    "@uniweb/schemas": "^0.12.0",
     "@uniweb/theming": "^0.2.0"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.29.2"
+    "@uniweb/runtime": "^0.29.4"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -74,8 +74,8 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "^0.37.2",
-    "@uniweb/runtime": "^0.29.2"
+    "@uniweb/runtime": "^0.29.4",
+    "@uniweb/core": "^0.38.0"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/dev/api-mount.js

@@ -5,7 +5,7 @@ import yaml from 'js-yaml'
 import { YAML_OPTIONS } from '../utils/yaml-schema.js'
 
 /**
- * Where `uniweb dev` answers the site's `api` service when `$devApi` names a handler.
+ * Where `uniweb dev` answers the site's `backend` service when `$devBackend` names a handler.
  * The dev server is the host here, so the address is its own.
  */
 export const DEV_API_ADDRESS = '/_api'
@@ -16,22 +16,24 @@ export const DEV_API_ADDRESS = '/_api'
  * A site that talks to a backend needs one running to be developed against, and
  * making that a live deployment is slow, costs money, and puts a shared database
  * behind a developer's experiments. So a site may name a **local handler**, and in
- * `uniweb dev` the dev server answers the site's `api` service with it:
+ * `uniweb dev` the dev server answers the site's `backend` service with it:
  *
  * ```yaml
  * # site.yml
  * services:
- *   api: true                # ask your host for an app backend (in production)
- * $devApi: ./mock/api.js     # what answers it in `uniweb dev`, at /_api
+ *   backend: true              # ask your host for it (in production)
+ * $devBackend: ./mock/api.js   # what answers it in `uniweb dev`, at /_api
  * ```
  *
  * ⭐ THE DEV SERVER SUPPLIES THE ADDRESS [Diego, 2026-10-06]. In `uniweb dev` it is
  * the host, so where it answers is its own to choose — `DEV_API_ADDRESS` — and the
- * plugin puts that address in the dev payload's `config.api`, the site tier
+ * plugin puts that address in the dev payload's `config.backend`, the site tier
  * `resolveService` reads when no host speaks. ⛔ *Until then the site wrote it, as a
  * top-level `api: /_api` "the same in development and in production" — an address
  * that, under `services:`, would read as "the site brings its own backend" and ask the
- * host to turn its own off.*
+ * host to turn its own off.* ⛔ *And until 2026-10-07 the service was `api` and this
+ * key `$devApi`; both are refused by those names now — `services.api` by
+ * `refuseUnreadableServices`, `$devApi` by `refuseRetiredServiceKeys`.*
  *
  * ```js
  * // mock/api.js — default-export a fetch handler
@@ -50,9 +52,9 @@ export const DEV_API_ADDRESS = '/_api'
  *
  * ## ⛔ Development only, and it cannot leak
  *
- * `$devApi` is read by the dev plugin and by nothing else: no build reads it, no
+ * `$devBackend` is read by the dev plugin and by nothing else: no build reads it, no
  * `info` key carries it, and only the dev server's payload names its address. What
- * answers the site's `api` service locally is a fact about one machine.
+ * answers the site's `backend` service locally is a fact about one machine.
  *
  * ⚠️ **Same-origin on purpose.** Mounting inside the dev server means cookies and
  * `credentials: 'same-origin'` behave as they do in production, where a site's app
@@ -87,7 +89,7 @@ export function mountDevApi(server, { root }) {
     return null
   }
 
-  const spec = site.$devApi
+  const spec = site.$devBackend
   if (!spec) return null
   const mount = DEV_API_ADDRESS
 

package/src/foundation/default-layout.js

@@ -0,0 +1,52 @@
+/**
+ * The layout a page renders with when it names none — decided once, by the build, and written
+ * into both artifacts: the entry's `capabilities.defaultLayout`, which the runtime reads
+ * (`Website.getDefaultLayoutName`), and `_self.defaultLayout` in the schema, which an editor
+ * reads to offer a page the areas it will draw. One rule, run once, so the two cannot disagree.
+ *
+ * ⭐ THE RULE [2026-10-07; Diego: "I think the default layout maybe called `default`"]:
+ *
+ *   1. `main.js`'s `defaultLayout`, written as that layout's own name — `DocsLayout` for
+ *      `docs` — so a reader finds it in `_layouts` by key. ⛔ One that names none of the
+ *      foundation's layouts stops the build: at render it fell to the built-in layout with
+ *      nothing saying why.
+ *   2. Else the layout whose name is `default`, by the one naming rule (`layoutNameKey`):
+ *      `Default`, `DefaultLayout`, `default-layout`.
+ *   3. Else none — the runtime's built-in layout, which draws `header`, the body and `footer`.
+ *
+ * ⛔ NOT "the only layout". Under that rule, adding a second layout would change the layout of
+ * every page that names none — a non-local effect nobody asked for. A foundation that means its
+ * one layout as the default says so, as every template does.
+ *
+ * ⛔ *Until 2026-10-07 the build copied the declared value and derived nothing, so a layout named
+ * `Default` was the default only when `main.js` said so — and a reader of the schema finding none
+ * had to guess what the runtime would draw.*
+ *
+ * @module @uniweb/build/foundation/default-layout
+ */
+
+import { findLayoutEntry } from '@uniweb/core/layout-name'
+
+/**
+ * @param {*} declared - `main.js`'s `defaultLayout`, as `loadFoundationConfig` reads it
+ * @param {string[]} layoutNames - the foundation's layouts (`discoverLayoutsInPath`)
+ * @returns {string|null} the layout's own name, or null for the built-in layout
+ * @throws {Error} when `declared` names none of the layouts
+ */
+export function resolveDefaultLayout(declared, layoutNames = []) {
+  const byName = Object.fromEntries((layoutNames || []).map((name) => [name, name]))
+
+  if (declared !== undefined && declared !== null && declared !== '') {
+    const name = typeof declared === 'string' ? findLayoutEntry(byName, declared) : undefined
+    if (name) return name
+    const known = Object.keys(byName)
+    throw new Error(
+      `main.js: \`defaultLayout\` names ${JSON.stringify(declared)}, which is not one of this foundation's layouts` +
+        (known.length > 0 ? ` (${known.join(', ')})` : ' — it has none in src/layouts/') +
+        '. Name one of them, or remove the key: a page that names no layout then renders the built-in ' +
+        'layout, or one named `Default`.'
+    )
+  }
+
+  return findLayoutEntry(byName, 'default') ?? null
+}

package/src/foundation/derive-supports.js

@@ -75,9 +75,10 @@
  *
  * ⚠️ `@uniweb/api` deliberately needs no entry: it calls
  * `resolveService(website, SERVICE_NAME)` against a module-level `const`, which
- * `readModuleConsts` resolves. Without that resolution `api` would be both
+ * `readModuleConsts` resolves. Without that resolution `backend` would be both
  * missed *and* counted as blindness, marking every foundation that uses it
- * unknowable.
+ * unknowable. ⛔ *The constant was `api` until 2026-10-07, so a foundation built
+ * against an earlier `@uniweb/api` derives `api` — a service no host offers now.*
  *
  * ## Why the AST rather than a regex
  *

package/src/generate-entry.js

@@ -32,6 +32,7 @@ import {
   LAYOUTS_PATH
 } from './schema.js'
 import { extractAllRuntimeSchemas, extractAllLayoutRuntimeSchemas, extractFoundationRuntime } from './runtime-schema.js'
+import { resolveDefaultLayout } from './foundation/default-layout.js'
 import { SCHEMA_EXTENSIONS } from './resolve-data-schema.js'
 
 /**
@@ -124,6 +125,7 @@ function generateEntrySource(components, options = {}) {
     cssPath = null,
     foundationExports = null,
     foundationRuntime = { code: [], data: {} },
+    defaultLayout = null,
     meta = {},
     layouts = {},
     layoutMeta = {},
@@ -188,6 +190,9 @@ function generateEntrySource(components, options = {}) {
       for (const key of foundationRuntime.code) capParts.push(`${key}: _foundationModule.default?.${key}`)
       for (const [key, value] of Object.entries(foundationRuntime.data)) capParts.push(`${key}: ${JSON.stringify(value)}`)
     }
+    // The resolved default, with or without a main.js — a layout named `Default` is one
+    // (`resolveDefaultLayout`), and `_self.defaultLayout` in the schema carries the same name.
+    if (defaultLayout) capParts.push(`defaultLayout: ${JSON.stringify(defaultLayout)}`)
     if (layoutNames.length > 0) {
       capParts.push(`layouts: { ${layoutNames.join(', ')} }`)
     }
@@ -310,6 +315,11 @@ export async function generateEntryPoint(srcDir, outputPath = null, options = {}
   const foundationExports = detectFoundationExports(srcDir)
   const foundationConfig = await loadFoundationConfig(srcDir)
   const foundationRuntime = foundationExports ? extractFoundationRuntime(foundationConfig) : { code: [], data: {} }
+  // Which layout a page that names none renders with — the build's answer, written here and in
+  // the schema's `_self.defaultLayout` (`buildSchema`) from one rule, so the runtime and an editor
+  // agree. It replaces the declared value `extractFoundationRuntime` copied.
+  const defaultLayout = resolveDefaultLayout(foundationConfig.defaultLayout, layoutNames)
+  delete foundationRuntime.data.defaultLayout
 
   // Per-component runtime metadata. ⭐ No data schema is resolved for it: the runtime reads a
   // declared key's ref and nothing of its shape (2026-10-05), so the entry no longer depends on
@@ -329,6 +339,7 @@ export async function generateEntryPoint(srcDir, outputPath = null, options = {}
     cssPath,
     foundationExports,
     foundationRuntime,
+    defaultLayout,
     meta,
     layouts,
     layoutMeta,

package/src/resolve-data-schema.js

@@ -161,7 +161,8 @@ export function collectSchemaRefs(components, foundationData = null) {
   const readData = (data) => {
     if (!data || typeof data !== 'object' || data === false) return
     for (const binding of Object.values(data)) {
-      // `'@std/article/*'` asks for whole records of `@std/article` — the ref is what precedes it.
+      // A ref, short or long (`{ schema, single, whole }`) — the flags change nothing about which
+      // schema the key is typed by.
       const { ref } = dataRefOf(binding)
       if (ref) refs.add(ref)
     }

package/src/runtime-schema.js

@@ -5,8 +5,9 @@
  * reads to render, and nothing else:
  *
  * - background: 'self' when component handles its own background
- * - data: { <key>: <schema ref> | null } — every `content.data` key the component
- *     declares, in order, with its schema ref (null for an inline shape)
+ * - data: { <key>: <schema ref> | { schema, single?, whole? } | null } — every `content.data`
+ *     key the component declares, in order, with its schema ref and the flags set on it (null for
+ *     an inline shape)
  * - vars: { <name>: { default? } } — the CSS variables the component declares
  * - defaults: param default values
  * - context: static capabilities for cross-block coordination
@@ -34,17 +35,34 @@
  */
 
 import { lowerData } from '@uniweb/schemas/content'
+import { schemaDeclarationOf } from '@uniweb/schemas/foundation'
 
 /**
- * A `data:` entry's schema ref — a ref string, or `{ schema }` — or null for an inline
- * shape, which names no schema and is filled only under its own key.
+ * A `data:` entry as the runtime reads it: its schema ref, with the flags set on it — or null for an
+ * inline shape, which names no schema and is filled only under its own key.
  *
- * @param {string|Object} value
- * @returns {string|null}
+ * ⭐ Two flags, independent (ruled 2026-10-07 [Diego]): `single` — one record, not a list — and
+ * `whole` — each record as stored, not its brief.
+ * Lean on purpose: the bare ref when neither is set, which is most keys, and only a flag that is set.
+ * ⛔ Until 2026-10-07 this wrote the ref alone, so `{ schema, whole: true }` lost its flag here and
+ * only the `'…/*'` spelling, now retired, reached the runtime.
+ *
+ * @param {string} key - the key, for a refusal
+ * @param {*} value - its value, as authored
+ * @returns {string|{ schema: string, single?: true, whole?: true }|null}
+ * @throws {Error} for a retired or malformed declaration (`schemaDeclarationOf`)
  */
-function dataRef(value) {
-  if (typeof value === 'string') return value || null
-  return value && typeof value === 'object' && typeof value.schema === 'string' && value.schema ? value.schema : null
+function leanDataValue(key, value) {
+  let declaration
+  try {
+    declaration = schemaDeclarationOf(value)
+  } catch (err) {
+    throw new Error(`[uniweb] Invalid 'data.${key}': ${err.message}`)
+  }
+  if (!declaration || !declaration.schema) return null
+  const { schema, single, whole } = declaration
+  if (!single && !whole) return schema
+  return { schema, ...(single ? { single: true } : {}), ...(whole ? { whole: true } : {}) }
 }
 
 /**
@@ -148,7 +166,7 @@ export function extractRuntimeSchema(fullMeta) {
         )
       }
       runtime.data = runtime.data || {}
-      runtime.data[key] = dataRef(value)
+      runtime.data[key] = leanDataValue(key, value)
     }
   } else if (data !== undefined) {
     throw new Error(
@@ -337,12 +355,12 @@ function leanVars(vars) {
   return Object.keys(out).length > 0 ? out : null
 }
 
-/** A foundation's `data:` as a section type's lean `data` is: each key → its schema ref, or null. */
+/** A foundation's `data:` as a section type's lean `data` is: each key → its ref and flags, or null. */
 function leanDataKeys(data) {
   const lowered = lowerData(data)
   if (!lowered || typeof lowered !== 'object' || Array.isArray(lowered)) return null
   const out = {}
-  for (const [key, value] of Object.entries(lowered)) out[key] = dataRef(value)
+  for (const [key, value] of Object.entries(lowered)) out[key] = leanDataValue(key, value)
   return Object.keys(out).length > 0 ? out : null
 }
 

package/src/schema.js

@@ -18,7 +18,8 @@ import { join, dirname, extname, basename } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { describeChildren, describeVisuals, lowerChildren } from '@uniweb/schemas/component'
 import { describeContent, lowerData } from '@uniweb/schemas/content'
-import { normalizeData } from '@uniweb/schemas/foundation'
+import { normalizeData, schemaDeclarationOf } from '@uniweb/schemas/foundation'
+import { rootListSection } from '@uniweb/schemas/conform'
 import { SECTION_PARAMS, SECTION_KEYS } from '@uniweb/schemas/section'
 import { collectSchemaRefs, buildDataSchemaMap, ownSchemaRefs } from './resolve-data-schema.js'
 import {
@@ -26,6 +27,8 @@ import {
   deriveRecordsSupport,
   unnameableIn,
 } from './foundation/derive-supports.js'
+import { RENAMED_SERVICES } from './uwx/services-request.js'
+import { resolveDefaultLayout } from './foundation/default-layout.js'
 import { foundationNameOf, splitFoundationName } from './foundation-name.js'
 import { resolveFoundationSrcDir } from './utils/foundation-source-root.js'
 
@@ -635,12 +638,67 @@ function buildComponentEntry(name, relativePath, meta) {
   else delete entry.children
 
   if (meta.data !== undefined) entry.data = lowerData(meta.data)
+  refuseDataDeclarations(`${name} (meta.js)`, entry.data)
 
   const problems = [...content.problems, ...describeChildren(meta).problems]
   if (problems.length > 0) loweringProblems.set(entry, problems)
   return entry
 }
 
+/**
+ * Refuse a `data:` key typed by a schema that is not written as one: the retired `/*` suffix, a
+ * property of the long form other than `schema`, `single` and `whole`, or a flag that is not a
+ * boolean (`schemaDeclarationOf`; ruled 2026-10-07 [Diego]). A refusal, not a warning: the runtime would
+ * read a mistyped flag as absent, and deliver a list where the author asked for one record.
+ *
+ * @param {string} owner - who declares it, for the message
+ * @param {*} data - a `data:` map, lowered
+ */
+function refuseDataDeclarations(owner, data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return
+  for (const [key, value] of Object.entries(data)) {
+    try {
+      schemaDeclarationOf(value)
+    } catch (err) {
+      throw new Error(`[uniweb] ${owner}: data.${key}: ${err.message}`)
+    }
+  }
+}
+
+/**
+ * Refuse `single` or `whole` on a key whose schema is a LIST — `@std/nav`, `@std/form`: a schema
+ * whose root is one list section describes the key's whole value, so the key holds that list, and
+ * neither one record of it nor a record as stored means anything. Checked once the schemas resolve.
+ *
+ * @param {Array<[string, *]>} owners - `[who, data:]` pairs
+ * @param {Object} dataSchemas - normalized schemas by ref
+ * @param {string} srcDir - to resolve a ref no binding brought in (a layout's)
+ */
+async function refuseFlagsOnListSchemas(owners, dataSchemas, srcDir) {
+  for (const [owner, data] of owners) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) continue
+    for (const [key, value] of Object.entries(data)) {
+      const declaration = schemaDeclarationOf(value)
+      if (!declaration || (!declaration.single && !declaration.whole)) continue
+      let schema = dataSchemas[declaration.schema]
+      if (!schema) {
+        try {
+          schema = (await buildDataSchemaMap([declaration.schema], { srcDir }))[declaration.schema]
+        } catch {
+          schema = null // an unresolvable ref is reported where refs resolve
+        }
+      }
+      if (schema && rootListSection(schema)) {
+        const flags = ['single', 'whole'].filter((flag) => declaration[flag]).map((flag) => `\`${flag}\``).join(' and ')
+        throw new Error(
+          `[uniweb] ${owner}: data.${key}: ${declaration.schema} is a list — its key holds that list, so ${flags} ` +
+            `does not apply. Write data.${key}: '${declaration.schema}'.`
+        )
+      }
+    }
+  }
+}
+
 /** `content: {}` or `content: []` — the component's way of saying it takes no content. */
 function declaresNoContent(content) {
   if (Array.isArray(content)) return content.length === 0
@@ -954,6 +1012,29 @@ export async function discoverComponents(srcDir, sectionPaths = DEFAULT_SECTION_
   return sections
 }
 
+/**
+ * Stop on a service `uniweb.supports` names by its old name (`RENAMED_SERVICES`), as
+ * `site.yml::services` does. A foundation claiming `api` claims a service no host offers
+ * now — and the build derives `backend` from the code itself, through kit's and
+ * `@uniweb/api`'s literals, so a renamed claim could only ever disagree with it.
+ *
+ * ⛔ Before the dev-rebuild bail, like `reportSupports`' warning: dev is where the
+ * developer is working.
+ *
+ * @param {string} srcDir
+ * @param {string[]|undefined} authored - normalized `uniweb.supports`
+ * @throws {Error} naming each old name and the new one
+ */
+function refuseRenamedSupports(srcDir, authored) {
+  const renamed = (authored || []).filter((s) => RENAMED_SERVICES[s])
+  if (!renamed.length) return
+  throw new Error(
+    `${srcDir}/package.json: \`uniweb.supports\` names ${renamed.map((s) => `\`${s}\``).join(', ')}, which is now ` +
+      `${renamed.map((s) => `\`${RENAMED_SERVICES[s]}\``).join(', ')} — the site's own backend is the \`backend\` ` +
+      'service. Rename it in package.json.',
+  )
+}
+
 /**
  * Say what the derivation added, at the one moment the developer is looking.
  *
@@ -1138,6 +1219,8 @@ export async function buildSchema(srcDir, sectionPaths, derivedSupports = null)
   // Load configuration from foundation.js
   const foundationConfig = await loadFoundationConfig(srcDir)
 
+  refuseDataDeclarations('the foundation (main.js)', lowerData(foundationConfig.data))
+
   // Discover section types
   const components = await discoverComponents(srcDir, sectionPaths)
   reportPlacementDeclarations(components)
@@ -1154,6 +1237,18 @@ export async function buildSchema(srcDir, sectionPaths, derivedSupports = null)
 
   // Discover layouts from src/layouts/
   const layouts = await discoverLayoutsInPath(srcDir)
+  // The layout a page that names none renders with — the entry gets the same answer
+  // (`generate-entry.js`), so an editor reading `_self.defaultLayout` offers what the runtime draws.
+  const defaultLayout = resolveDefaultLayout(foundationConfig.defaultLayout, Object.keys(layouts))
+  await refuseFlagsOnListSchemas(
+    [
+      ...Object.entries(components).map(([name, entry]) => [`${name} (meta.js)`, entry?.data]),
+      ...Object.entries(layouts).map(([name, entry]) => [`layout ${name} (meta.js)`, entry?.data]),
+      ['the foundation (main.js)', lowerData(foundationConfig.data)],
+    ],
+    dataSchemas,
+    srcDir,
+  )
   reportUnregistrableData(components, layouts, foundationConfig)
 
   // Determine extension role
@@ -1169,8 +1264,9 @@ export async function buildSchema(srcDir, sectionPaths, derivedSupports = null)
     }
   }
 
-  // Build _self, stripping the raw extension boolean in favor of normalized role
-  const { extension: _ext, ...configWithoutExtension } = foundationConfig
+  // Build _self, stripping the raw extension boolean in favor of normalized role, and the
+  // declared `defaultLayout` in favor of the resolved one (`resolveDefaultLayout`)
+  const { extension: _ext, defaultLayout: _declaredLayout, ...configWithoutExtension } = foundationConfig
 
   // `supports` is the one identity field the build knows better than the file.
   // `identity.supports` is already normalized (absent stays absent, `[]` stays
@@ -1188,6 +1284,7 @@ export async function buildSchema(srcDir, sectionPaths, derivedSupports = null)
   // `supports` differs from the one a real build produces is a trap rather than a
   // convenience — the artifact would disagree with itself depending on which
   // command wrote it. One rule: the derivation runs on a real build.
+  refuseRenamedSupports(srcDir, identity.supports)
   const derived = derivedSupports && {
     ...derivedSupports,
     services: deriveRecordsSupport(components, foundationConfig.data)
@@ -1211,7 +1308,7 @@ export async function buildSchema(srcDir, sectionPaths, derivedSupports = null)
       ...supports,
       ...(name && { name }),
       ...(foundationConfig.description && { description: foundationConfig.description }),
-      ...(foundationConfig.defaultLayout && { defaultLayout: foundationConfig.defaultLayout }),
+      ...(defaultLayout && { defaultLayout }),
       ...(isExtension && { role: 'extension' }),
       // The build's fact, last: which form the entries below hold.
       schemaFormat: SCHEMA_FORMAT,

package/src/site/content-collector.js

@@ -22,7 +22,7 @@
  */
 
 import { readFile, readdir, stat } from 'node:fs/promises'
-import { resolveQueriesConfig, toConfigQueries } from './queries-config.js'
+import { resolveQueriesConfig, toConfigQueries, dataKeyTyping } from './queries-config.js'
 import { isSectionKey } from '@uniweb/schemas/section'
 import { parseNumericPrefix, compareByNumericPrefix } from '../utils/numeric-prefix.js'
 import { isMarkdownFile, isIgnoredFolder } from '../utils/content-files.js'
@@ -41,7 +41,7 @@ import { resolveDefaultLocale, resolvePublishableLocales, validateLanguageConfig
 import { authoredRedirectTarget } from '@uniweb/core/resolve-route'
 import { parseFrontmatter } from '../utils/frontmatter.js'
 import { parseGrid } from '@uniweb/schemas/grid'
-import { runtimeServicesConfig, refuseRetiredServiceKeys } from '../uwx/services-request.js'
+import { runtimeServicesConfig, refuseRetiredServiceKeys, refuseUnreadableServices } from '../uwx/services-request.js'
 
 // Try to import content-reader, fall back to simplified parser
 let markdownToProseMirror
@@ -2503,6 +2503,7 @@ export async function collectSiteContent(sitePath, options = {}) {
   // Read site config and raw theme config
   const siteConfig = await readYamlFile(join(sitePath, configFile))
   refuseRetiredServiceKeys(siteConfig, configFile)
+  refuseUnreadableServices(siteConfig, configFile)
 
   // Queries are declared in TWO files — `site.yml::queries` and `queries.yml`,
   // the latter winning per key — and resolving them is one question with one
@@ -2510,13 +2511,17 @@ export async function collectSiteContent(sitePath, options = {}) {
   // merged both, so a declaration in the second file was invisible here: never
   // compiled, `data: <name>` delivering nothing, while sync pushed it fine.
   //
-  // ⭐ `config.queries` — framework's own payload key, framework's own readers.
-  // The backend's projector never emits it (their measurement: 17 `config` keys,
-  // not this one), and hosting renders with framework's code. There was nobody to
-  // coordinate with, which is exactly why it had no excuse to stay wrong.
-  const byQuery = toConfigQueries(
-    (await resolveQueriesConfig(sitePath, { siteYml: siteConfig })).declarations
-  )
+  // ⭐ `config.queries` — what a page's queries are, which a section's keys are filled by. A
+  // backend-served payload carries its own projection of each (`schema`, `where`, `sort`,
+  // `limit`, `scope`) since 2026-09-05. ⛔ This said the backend's projector never emitted it,
+  // which was true only before then.
+  //
+  // ⭐ A query a data key types carries the type, as a push names it (`dataKeyTyping`), so a key
+  // typed `@/post` fills from `articles:` on a static site as it does on a hosted one.
+  const { declarations } = await resolveQueriesConfig(sitePath, { siteYml: siteConfig })
+  const nameDefaulted = Object.values(declarations).some((d) => d?.schemaExplicit === false)
+  const typing = nameDefaulted ? await dataKeyTyping(sitePath, declarations, { siteYml: siteConfig }) : null
+  const byQuery = toConfigQueries(declarations, typing)
   if (byQuery) siteConfig.queries = byQuery
 
   // Record the RESOLVED base (--base > UNIWEB_BASE > site.yml::base) on the

package/src/site/deploy-config-writer.js

@@ -7,8 +7,10 @@
  * must not destroy a developer's comments on the targets:/saveDeploys:
  * regions of the file.
  *
- * This is the only place in @uniweb/build that depends on `yaml`. The
- * loader (deploy-config.js) stays on js-yaml for read-only ingestion.
+ * The loader (deploy-config.js) stays on js-yaml for read-only ingestion.
+ * ⚠️ This read "the only place in @uniweb/build that depends on `yaml`" until
+ * 2026-10-07; the pull's config writers locate entries with it too
+ * (`uwx/yaml-edit.js::editYamlText`), and print with js-yaml.
  *
  * `saveDeploys: false` (or `--no-save`) makes this a no-op; otherwise it
  * touches ONLY deploys.<targetName> — plus targets.<targetName> when the file has no

package/src/site/plugin.js

@@ -655,16 +655,16 @@ export function siteContentPlugin(options = {}) {
   }
 
   let siteContent = null
-  // Where `uniweb dev` answers the site's `api` service with `$devApi`'s handler — set
+  // Where `uniweb dev` answers the site's `backend` service with `$devBackend`'s handler — set
   // in `configureServer`, so never in a build.
   let devApiAddress = null
   /**
-   * The dev payload names `$devApi`'s address as the site's `api` service: the site
+   * The dev payload names `$devBackend`'s address as the site's `backend` service: the site
    * tier, which `resolveService` reads when no host speaks. A build never gets here
    * with one.
    */
   const withDevApi = (content) => {
-    if (devApiAddress && content?.config) content.config.api = devApiAddress
+    if (devApiAddress && content?.config) content.config.backend = devApiAddress
     return content
   }
   // What each section type declares its data blocks are — read once per collection of the site.
@@ -1009,10 +1009,10 @@ export function siteContentPlugin(options = {}) {
     configureServer(devServer) {
       server = devServer
 
-      // A site's own backend, answered locally in development. `site.yml::$devApi`
+      // A site's own backend, answered locally in development. `site.yml::$devBackend`
       // names a module that default-exports a fetch handler; the dev server mounts it
       // at an address of its own and names that address in the payload it serves
-      // (`withDevApi`), so the site's `api` service resolves to it.
+      // (`withDevApi`), so the site's `backend` service resolves to it.
       // ⚠️ Synchronous on purpose — see mountDevApi. An await here and the
       // middleware lands after Vite's SPA fallback, which answers the API with
       // index.html and says nothing about why.