@uniweb/build 0.75.1 → 0.76.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.75.1",
+  "version": "0.76.1",
   "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.13",
+    "@uniweb/content-reader": "^1.2.8",
     "@uniweb/content-writer": "^0.3.4",
+    "@uniweb/projections": "^0.7.14",
+    "@uniweb/schemas": "^0.12.0",
     "@uniweb/semantic-parser": "^1.5.1",
-    "@uniweb/content-reader": "^1.2.8",
-    "@uniweb/schemas": "^0.10.2",
     "@uniweb/theming": "^0.2.0"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.28.10"
+    "@uniweb/runtime": "^0.29.1"
   },
   "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/runtime": "^0.28.10",
-    "@uniweb/core": "^0.36.0"
+    "@uniweb/runtime": "^0.29.1",
+    "@uniweb/core": "^0.37.1"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/dev/plugin.js

@@ -243,9 +243,9 @@ export function foundationDevPlugin(options = {}) {
           // Ignore generated files (build output triggers entry regeneration)
           if (!filename || filename.includes('_entry.generated')) return
 
-          // Rebuild for source file changes, and for any file the entry is generated
-          // from — a data schema under `schemas/` is `.yml` or `.json` as often as `.js`
-          // (`shouldRegenerateForFile`)
+          // Rebuild for source file changes, and for the other structural files
+          // (`shouldRegenerateForFile`) — a data schema under `schemas/`, `.yml` or `.json`
+          // as often as `.js`, moves the rebuilt schema.json
           if (
             filename.endsWith('.js') ||
             filename.endsWith('.jsx') ||

package/src/generate-entry.js

@@ -12,7 +12,7 @@
  * The `meta` export contains only properties needed at runtime:
  * - `background` - 'self' opt-out when component handles its own background
  * - `data` - the `content.data` keys the component declares, with their schema refs
- * - `schemas` - field defaults for those keys
+ * - `vars` - the CSS variables the component declares, with their defaults
  * - `defaults` - Param default values
  * - `context` - Static capabilities for cross-block coordination
  * - `initialState` - Initial values for mutable block state
@@ -32,7 +32,7 @@ import {
   LAYOUTS_PATH
 } from './schema.js'
 import { extractAllRuntimeSchemas, extractAllLayoutRuntimeSchemas, extractFoundationRuntime } from './runtime-schema.js'
-import { collectSchemaRefs, buildDataSchemaMap, SCHEMA_EXTENSIONS } from './resolve-data-schema.js'
+import { SCHEMA_EXTENSIONS } from './resolve-data-schema.js'
 
 /**
  * The files a foundation's data schemas are read from, relative to its source root:
@@ -196,12 +196,12 @@ function generateEntrySource(components, options = {}) {
     lines.push('const capabilities = null')
   }
 
-  // Per-component runtime metadata (defaults, context, initialState, background, data)
+  // Per-component runtime metadata (defaults, context, initialState, background, data, vars)
   lines.push('')
   const metaJson = JSON.stringify(Object.keys(meta).length > 0 ? meta : {}, null, 2)
   lines.push(`const meta = ${metaJson}`)
 
-  // Per-layout runtime metadata (areas, transitions, defaults)
+  // Per-layout runtime metadata (transitions, layers, scroll, defaults)
   lines.push('')
   const layoutMetaJson = JSON.stringify(Object.keys(layoutMeta).length > 0 ? layoutMeta : {}, null, 2)
   lines.push(`const layoutMeta = ${layoutMetaJson}`)
@@ -311,23 +311,12 @@ export async function generateEntryPoint(srcDir, outputPath = null, options = {}
   const foundationConfig = await loadFoundationConfig(srcDir)
   const foundationRuntime = foundationExports ? extractFoundationRuntime(foundationConfig) : { code: [], data: {} }
 
-  // Resolve the data schemas referenced by section bindings, then extract
-  // per-component runtime metadata (which lean-extracts field defaults from
-  // the resolved schemas into meta.schemas[<key>]).
-  // ⛔ Components only, unlike `schema.js`, which also passes the foundation's
-  // `main.js` `data:`. Not an oversight: this map feeds `extractAllRuntimeSchemas`,
-  // and `extractRuntimeSchema` reads `fullMeta.data` — per component. A
-  // foundation-tier key reaches every section (`declaredKeys`) but has nowhere to
-  // put its lean schema in a PER-COMPONENT runtime meta, so resolving its ref here
-  // would produce an entry nothing reads.
-  //
-  // ⚠️ The consequence is real and still open: a foundation-tier `data:` entry
-  // naming a schema gets no field defaults from `applySchemas` at runtime. Latent
-  // today — every foundation-tier declaration in the templates is ref-less — and
-  // fixing it means deciding where a foundation-wide schema lives in the runtime
-  // meta, which is a design question, not a missing argument.
-  const dataSchemaMap = await buildDataSchemaMap(collectSchemaRefs(components), { srcDir })
-  const meta = extractAllRuntimeSchemas(components, dataSchemaMap)
+  // 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
+  // a schema file — `schema.js` resolves them, for schema.json, and a missing one stops the
+  // build there. ⛔ Until then the entry carried each key's field defaults, resolved here, and a
+  // foundation-tier `data:` key got none, having no per-component place to put them.
+  const meta = extractAllRuntimeSchemas(components)
 
   // Extract per-layout runtime metadata from meta.js files
   const layoutMeta = extractAllLayoutRuntimeSchemas(layouts)
@@ -519,13 +508,11 @@ export function shouldRegenerateForFile(file, srcDir) {
     }
   }
 
-  // ⭐ The foundation's data schemas — `schemas/<name>.<ext>` and `schemas.config.js`.
-  // The entry's `meta` carries each declared `data:` key with its schema's field
-  // defaults, and a `@/name` ref whose file is missing stops entry generation. A
-  // section receives only the keys its entry declares (2026-09-14), so an entry that
-  // falls behind withholds data: a `data:` key declaring `@/member` before
-  // `schemas/member.yml` exists fails the regeneration, and until 2026-09-14 writing
-  // the file triggered no other — the dev server kept the entry without the key.
+  // The foundation's data schemas — `schemas/<name>.<ext>` and `schemas.config.js`.
+  // ⚠️ The entry holds nothing read from one since 2026-10-05 (no field defaults), so
+  // regenerating it changes nothing. The match stays for the dev rebuild of a
+  // runtime-linked foundation (`dev/plugin.js`), which also writes the editor's
+  // schema.json — whose `dataSchemas` a schema change does move.
   if (rel.startsWith(`${SCHEMAS_PATH}/`)) {
     const inner = rel.slice(SCHEMAS_PATH.length + 1)
     if (!inner.includes('/') && SCHEMA_EXTENSIONS.some(ext => inner.endsWith(ext))) {

package/src/prerender.js

@@ -23,7 +23,7 @@ import {
   deriveCacheKey,
   evaluateQuery,
 } from '@uniweb/core'
-import { recordTitle, routePatternToRegex, routeFieldOf } from '@uniweb/core/route-match'
+import { recordTitle, recordImage, routePatternToRegex, routeFieldOf } from '@uniweb/core/route-match'
 import DataStore from '@uniweb/core/datastore'
 import { executeFetch, mergeDataIntoContent, toFetchList } from './site/data-fetcher.js'
 import { createFileTransport } from './site/file-transport.js'
@@ -473,6 +473,9 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
         const title = recordTitle(item)
         if (title) concretePage.title = title
         if (item.description || item.excerpt) concretePage.description = item.description || item.excerpt
+        // ⭐ And its picture is what a link to the page shows (`recordImage`) — the SPA's rule.
+        const image = recordImage(item)
+        if (image) concretePage.seo = { ...(concretePage.seo || {}), image }
 
         expandedPages.push(concretePage)
       }

package/src/resolve-data-schema.js

@@ -84,6 +84,60 @@ export const SCHEMA_NOT_FOUND = 'SCHEMA_NOT_FOUND'
 const RESERVED_SYSTEM_SCOPE = 'uniweb'
 const packageForScope = (scope) => SCOPE_PACKAGE[scope] ?? `@${scope}/schemas`
 
+/**
+ * A NAMED data schema — a `schemas/` file, `@std/<name>`, `@org/<name>` — validated and
+ * normalized, and refused when a field declares a `default`.
+ *
+ * ⛔ A named schema declares no default — ruled 2026-10-05 [Diego], when the runtime stopped
+ * filling fields: nothing would read one. The runtime fills no field, the declaration a
+ * registry stores carries none (`uwx/data-schema.js`), and the foundation schema an editor
+ * reads leaves `dataSchemas` out (`uwx/registry-package.js`) — so a `default:` here would be a
+ * promise kept nowhere. What an absent field renders as is the component's choice. A default
+ * stays where an editor reads it: a component's own inline field map or form in `data:`.
+ *
+ * @param {object} schema - the schema as authored
+ * @param {string} ref - its ref, for the message
+ * @returns {object} the normalized schema
+ */
+function normalizeNamedSchema(schema, ref) {
+  const normalized = validateAndNormalizeSchema(schema, ref)
+  const paths = fieldsWithDefaults(normalized)
+  if (paths.length > 0) {
+    throw new Error(
+      `Data schema '${ref}': a named data schema declares no default — remove \`default:\` from ` +
+        `${paths.map((p) => `'${p}'`).join(', ')}. A component decides what an absent field ` +
+        `renders as; an editor pre-fills from a component's own inline field map or form in \`data:\`.`
+    )
+  }
+  return normalized
+}
+
+/** The dotted paths of every field in a normalized schema that declares a `default`. */
+function fieldsWithDefaults(schema) {
+  const found = []
+  const walkFields = (fields, prefix) => {
+    if (!fields || typeof fields !== 'object') return
+    for (const [name, spec] of Object.entries(fields)) walkSpec(spec, `${prefix}${name}`)
+  }
+  const walkSpec = (spec, path) => {
+    if (!spec || typeof spec !== 'object') return
+    if (spec.default !== undefined) found.push(path)
+    walkFields(spec.fields, `${path}.`)
+    if (spec.items) walkSpec(spec.items, `${path}[]`)
+    if (spec.values) walkSpec(spec.values, `${path}{}`)
+  }
+  const walkSections = (sections, prefix) => {
+    if (!sections || typeof sections !== 'object') return
+    for (const [name, section] of Object.entries(sections)) {
+      walkFields(section?.fields, `${prefix}${name}.`)
+      walkSections(section?.sections, `${prefix}${name}.`)
+    }
+  }
+  walkFields(schema?.fields, '')
+  walkSections(schema?.sections, '')
+  return found
+}
+
 /**
  * Collect every distinct schema ref used by a foundation's section bindings.
  * Reads `data: { key: '<ref>' }` (short) and `data: { key: { schema: '<ref>' } }`
@@ -94,9 +148,9 @@ const packageForScope = (scope) => SCOPE_PACKAGE[scope] ?? `@${scope}/schemas`
  * (`declaredKeys`, `@uniweb/core/data-keys`) — but only components were scanned
  * here, so a ref at that tier was neither resolved into `dataSchemas` nor
  * rejected when dangling, while the key was still delivered at runtime. The
- * symptom would have been no schema for the editor and no field defaults from
- * `applySchemas`, with no build error. It bit nobody only because every
- * foundation-tier declaration in the templates is ref-less.
+ * symptom would have been no schema for the editor, with no build error. It bit
+ * nobody only because every foundation-tier declaration in the templates is
+ * ref-less.
  *
  * @param {Object} components - Map of componentName → full meta (with `data`)
  * @param {Object|false|null} [foundationData] - the foundation's `main.js` `data:`
@@ -136,7 +190,7 @@ export async function resolveSchemaRef(ref, { srcDir, aliases }) {
         { code: SCHEMA_NOT_FOUND }
       )
     }
-    return validateAndNormalizeSchema(await loadSchemaFile(file), ref)
+    return normalizeNamedSchema(await loadSchemaFile(file), ref)
   }
 
   // ⭐ THE SYSTEM MODELS A SITE'S RECORDS MAY NAME — `@uniweb/link` — resolve from the build's own
@@ -145,7 +199,7 @@ export async function resolveSchemaRef(ref, { srcDir, aliases }) {
   // never a data-schema source. (The whole scope was refused until 2026-09-28.)
   if (scope === RESERVED_SYSTEM_SCOPE) {
     const system = SYSTEM_RECORD_SCHEMAS[name]
-    if (system) return validateAndNormalizeSchema(system, ref)
+    if (system) return normalizeNamedSchema(system, ref)
     const allowed = Object.keys(SYSTEM_RECORD_SCHEMAS).map((n) => `'@${scope}/${n}'`).join(', ')
     throw new Error(
       `'@${scope}' is the reserved platform system namespace: the only data schemas a site's records ` +
@@ -170,7 +224,7 @@ export async function resolveSchemaRef(ref, { srcDir, aliases }) {
           `exists there. Point it at a ${SCHEMA_EXTENSIONS.join(' / ')} file.`
       )
     }
-    return validateAndNormalizeSchema(await loadSchemaFile(file), ref)
+    return normalizeNamedSchema(await loadSchemaFile(file), ref)
   }
 
   // A scope alias ('@org' → a DIR) resolves 'name' to a bare schema FILE in that
@@ -195,7 +249,7 @@ export async function resolveSchemaRef(ref, { srcDir, aliases }) {
       }
       throw new Error(msg)
     }
-    return validateAndNormalizeSchema(await loadSchemaFile(file), ref)
+    return normalizeNamedSchema(await loadSchemaFile(file), ref)
   }
 
   // Every other scope is an org namespace: '@org/name' resolves `name` from that
@@ -207,7 +261,7 @@ export async function resolveSchemaRef(ref, { srcDir, aliases }) {
   if (!schema) {
     throw new Error(`Unknown data schema '${ref}': '${pkg}' exports no schema named '${name}'.`)
   }
-  return validateAndNormalizeSchema(schema, ref)
+  return normalizeNamedSchema(schema, ref)
 }
 
 /**
@@ -224,9 +278,8 @@ export async function resolveSchemaRef(ref, { srcDir, aliases }) {
 export async function buildDataSchemaMap(refs, { srcDir }) {
   // Load the foundation's optional schemas.config.js once; every ref (and every
   // transitively-discovered ref) resolves against the same alias map. This is
-  // the single entry both schema discovery and the runtime-schema build go
-  // through, so editor schema.json, runtime defaults, and `uniweb validate` all
-  // resolve refs identically.
+  // the single entry schema discovery and `uniweb validate` go through, so the
+  // editor's schema.json and the check of a site's data resolve refs identically.
   const aliases = await loadSchemaAliases(srcDir)
   const map = {}
   const queue = Array.from(refs)
@@ -299,7 +352,7 @@ async function collectSchemasFromExports(packageDir) {
   for (const name of names) {
     const schema = get(name)
     if (!schema || typeof schema !== 'object') continue
-    out[`@/${name}`] = validateAndNormalizeSchema(schema, `@/${name}`)
+    out[`@/${name}`] = normalizeNamedSchema(schema, `@/${name}`)
   }
   return out
 }
@@ -309,7 +362,7 @@ async function collectSchemasFromExports(packageDir) {
 async function collectSchemasFromDir(dir) {
   const out = {}
   for (const { file, name } of schemaFilesIn(dir)) {
-    out[`@/${name}`] = validateAndNormalizeSchema(await loadSchemaFile(join(dir, file)), `@/${name}`)
+    out[`@/${name}`] = normalizeNamedSchema(await loadSchemaFile(join(dir, file)), `@/${name}`)
   }
   return out
 }

package/src/runtime-schema.js

@@ -1,14 +1,13 @@
 /**
  * Runtime Schema Extractor
  *
- * Extracts lean runtime-relevant metadata from full meta.js files.
- * The runtime schema is optimized for size and contains only what's
- * needed at render time:
+ * Extracts lean runtime-relevant metadata from full meta.js files — what a published page
+ * 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)
- * - schemas: { <key>: <lean fields> } — field defaults for the declared keys that have any
+ * - vars: { <name>: { default? } } — the CSS variables the component declares
  * - defaults: param default values
  * - context: static capabilities for cross-block coordination
  * - initialState: initial values for mutable block state
@@ -20,14 +19,20 @@
  * delivery was default-on — every key that reached a section — and `data:` was a hint for
  * defaults and the editor; `data: false` was the opt-out, emitted as `inheritData: false`.
  *
+ * ⛔ NO FIELD DEFAULTS — ruled 2026-10-05 [Diego]. Each declared key also carried `schemas`
+ * until then — its schema's field defaults, with `enum` and the nesting that led to them — and
+ * the runtime filled a missing field from its `default` and replaced a value its `enum`
+ * rejected. A missing field is the record's own fact, and what it renders as is the
+ * component's choice; a copy frozen into the bundle drifts from the schema it was taken from;
+ * and checking a value is `uniweb validate`'s and the push's job, not the page's. A form in
+ * `data:` is the editor's, for authoring the block: none of it reaches the runtime.
+ * ⛔ Nor `inset` (an editor's flag — an inset is found by name) or a layout's `areas` (a page's
+ * areas are its site's `layout/` folder): no runtime reader read either, until 2026-10-05.
+ *
  * Full metadata (titles, descriptions, hints, etc.) stays in schema.json
  * for the visual editor.
  */
 
-import { isRichSchema } from '@uniweb/core'
-import { dataRefOf } from '@uniweb/core/data-keys'
-import { briefFieldMap, wholeFieldMap } from '@uniweb/schemas/conform'
-import { enumValues } from '@uniweb/schemas/format'
 import { lowerData } from '@uniweb/schemas/content'
 
 /**
@@ -42,188 +47,6 @@ function dataRef(value) {
   return value && typeof value === 'object' && typeof value.schema === 'string' && value.schema ? value.schema : null
 }
 
-/**
- * Extract lean schema field for runtime
- * Strips editor-only fields (label, hint, description)
- * Keeps runtime fields (type, default, enum, options, fields, items)
- *
- * Vocabulary is the data-schema format:
- * an `object` field nests via `fields:` (a field map); an `array` field nests
- * via `items:` (a single element field). This matches what
- * resolve-data-schema.js normalizes named refs to, so named-ref and inline
- * `data:` schemas share one shape.
- *
- * @param {string|Object} field - Schema field definition
- * @returns {string|Object} - Lean field definition
- */
-function extractSchemaField(field) {
-  // Shorthand: a bare type string ('string', 'decimal', …).
-  if (typeof field === 'string') {
-    return field
-  }
-
-  if (!field || typeof field !== 'object') {
-    return field
-  }
-
-  const lean = {}
-
-  // Keep runtime-relevant fields: the default, plus the inline picklist
-  // (`enum`) used for value validation. `options` is a curated-ref string —
-  // inert at runtime but carried through.
-  if (field.type) lean.type = field.type
-  if (field.default !== undefined) lean.default = field.default
-  // The values only: an entry's label (`{ value, label }`) is an editor's, and the runtime compares.
-  if (field.enum !== undefined) lean.enum = enumValues(field.enum)
-  if (field.options) lean.options = field.options
-
-  // Nested object → recurse into its field map.
-  if (field.type === 'object' && field.fields && typeof field.fields === 'object') {
-    lean.fields = extractSchemaFields(field.fields)
-  }
-
-  // Array → recurse into its single element field (which may itself be an
-  // object carrying nested `fields`).
-  if (field.type === 'array' && field.items !== undefined) {
-    lean.items = extractSchemaField(field.items)
-  }
-
-  // If the only thing left is `type`, collapse to the bare type string.
-  const keys = Object.keys(lean)
-  if (keys.length === 1 && keys[0] === 'type') {
-    return lean.type
-  }
-
-  return keys.length > 0 ? lean : null
-}
-
-/**
- * Extract lean schema fields for an entire schema object
- *
- * @param {Object} schemaFields - Map of fieldName -> field definition
- * @returns {Object} - Map of fieldName -> lean field definition
- */
-function extractSchemaFields(schemaFields) {
-  if (!schemaFields || typeof schemaFields !== 'object') {
-    return {}
-  }
-
-  const lean = {}
-  for (const [name, field] of Object.entries(schemaFields)) {
-    const leanField = extractSchemaField(field)
-    if (leanField !== null) {
-      lean[name] = leanField
-    }
-  }
-  return lean
-}
-
-/**
- * Check if a schema value is in the full @uniweb/schemas format
- * Full format has: { name, version?, description?, fields: { fieldName: fieldDef, ... } }
- *
- * The distinguishing feature is that `fields` is a *keyed object*, not an array.
- * (A rich form schema also has `fields`, but as an array.)
- *
- * @param {Object} schema - Schema value to check
- * @returns {boolean}
- */
-function isFullSchemaFormat(schema) {
-  return (
-    schema &&
-    typeof schema === 'object' &&
-    typeof schema.fields === 'object' &&
-    schema.fields !== null &&
-    !Array.isArray(schema.fields)
-  )
-}
-
-/**
- * Pass a rich form schema through with minimal normalization.
- *
- * Rich schemas are passed to the editor (for FormBlock UI rendering) and to
- * the runtime (for default application). We keep all authored metadata so the
- * editor has what it needs; we do not strip editor-only fields here because
- * the same schema feeds both audiences.
- *
- * Normalizations:
- *
- * @param {Object} schema - Rich schema as authored
- * @returns {Object} - Normalized rich schema
- */
-function normalizeRichSchema(schema) {
-  return normalizeRichSchemaValue(schema)
-}
-
-function normalizeRichSchemaValue(value) {
-  if (Array.isArray(value)) {
-    return value.map(normalizeRichSchemaValue)
-  }
-  if (!value || typeof value !== 'object') return value
-  const out = {}
-  for (const [key, v] of Object.entries(value)) {
-    if (v && typeof v === 'object') {
-      out[key] = normalizeRichSchemaValue(v)
-    } else {
-      out[key] = v
-    }
-  }
-  return out
-}
-
-/**
- * Lean a single `data:` entry value into the runtime field structure that
- * prepare-props.applySchemas applies. A `data:` value is one of:
- *   - a named ref (`'@/member'`, or `{ schema: '@/member' }`) → resolved on
- *     disk by the build's data-schema resolver; its fields are lean-extracted.
- *   - an inline rich-form schema (`{ fields: [...] }`) → passed through
- *     normalized (drives the FormBlock editor UI + default application).
- *   - an inline full-format schema (`{ name, version, fields: {...} }`) or a
- *     bare field map (`{ field: {...} }`) → lean-extracted.
- *
- * Source-agnostic: the same `content.data` key may be filled by a fetched
- * collection, a tagged code block, or an editor form — the schema (and its
- * defaults) is identical, so there is one declaration surface. Returns the
- * lean structure, or null when there's nothing to apply.
- *
- * @param {string|Object} value - The `data:` entry value
- * @param {Object} dataSchemaMap - Resolved schemas keyed by ref
- * @returns {Object|null}
- */
-function leanDataSchema(value, dataSchemaMap) {
-  // Named ref → the resolved schema's fields. `'@std/article/*'` asks for whole records of it.
-  const { ref, whole } = dataRefOf(value)
-  if (ref) {
-    const resolved = dataSchemaMap[ref]
-    // ⭐ THE FIELDS OF WHAT THE COMPONENT RECEIVES (ruled 2026-09-27 [Diego]): a brief's fields at
-    // the top (`briefFieldMap`), or, for `'@x/y/*'`, the whole record as stored — one field per
-    // section, the brief's included (`wholeFieldMap`) — so a default lands where the record carries
-    // its field: `@std/article`'s `status` inside `body`. A section is filled only when the record
-    // holds it (`applySchemaToObject` recurses into what is there).
-    //
-    // ⛔ It was the merged `deliveredFields` until 2026-09-27 — the brief's fields beside the other
-    // sections' names, one map for two shapes; `flatRecordFields`, the retired flat form, until
-    // 2026-09-24; and before 2026-09-03 `resolved.fields`, which a sections-form schema does not
-    // have. `dataSchemaMap` holds each schema normalized in its authored form (`fields:` or
-    // `sections:`), and only these readers say what one record of it looks like.
-    const fields = whole ? wholeFieldMap(resolved) : briefFieldMap(resolved)
-    if (!fields) return null
-    const lean = extractSchemaFields(fields)
-    return Object.keys(lean).length > 0 ? lean : null
-  }
-
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
-
-  // Inline rich-form schema (fields: array) — drives FormBlock + defaults.
-  if (isRichSchema(value)) return normalizeRichSchema(value)
-
-  // Inline full-format schema or a bare field map.
-  const fields = isFullSchemaFormat(value) ? value.fields : value
-  const lean = extractSchemaFields(fields)
-  return Object.keys(lean).length > 0 ? lean : null
-}
-
-
 /**
  * Extract param defaults from params object
  *
@@ -246,27 +69,45 @@ function extractParamDefaults(params) {
   return Object.keys(defaults).length > 0 ? defaults : null
 }
 
+/**
+ * A section type's CSS variables as the runtime reads them: every declared name, with its
+ * `default` when it has one. `Block.mergeComponentVars` (`@uniweb/core`) emits each default
+ * on the section and takes a section's `vars:` value only for a name declared here, so a
+ * var with no default still needs its name. A label, a type, options and a description are
+ * the editor's. A shorthand value (`'card-gap': '1.5rem'`) is written as its `default`.
+ *
+ * ⛔ Not emitted until 2026-10-05, while core read it since 2026-03-02: a section type's
+ * `vars:` reached no page, and neither did a section's `vars:` for them.
+ *
+ * @param {Object} vars - the `vars:` of a meta.js
+ * @returns {Object|null} `{ <name>: { default? } }`, or null when none is declared
+ */
+function leanComponentVars(vars) {
+  if (!vars || typeof vars !== 'object' || Array.isArray(vars)) return null
+  const out = {}
+  for (const [name, config] of Object.entries(vars)) {
+    if (config !== null && typeof config === 'object' && !Array.isArray(config)) {
+      out[name] = config.default !== undefined ? { default: config.default } : {}
+    } else {
+      out[name] = config === null || config === undefined ? {} : { default: config }
+    }
+  }
+  return Object.keys(out).length > 0 ? out : null
+}
+
 /**
  * Extract lean runtime schema from a full meta.js object
  *
  * @param {Object} fullMeta - The full meta.js default export
- * @param {Object} [dataSchemaMap] - Resolved data schemas keyed by ref (from
- *                 resolve-data-schema.js), used to lean-extract field defaults
- *                 for each `data:` binding.
  * @returns {Object|null} - Lean runtime schema or null if empty
  */
-export function extractRuntimeSchema(fullMeta, dataSchemaMap = {}) {
+export function extractRuntimeSchema(fullMeta) {
   if (!fullMeta || typeof fullMeta !== 'object') {
     return null
   }
 
   const runtime = {}
 
-  // Inset flag: signals this component is available for inline @ references
-  if (fullMeta.inset) {
-    runtime.inset = true
-  }
-
   // Background opt-out: 'self' means the component renders its own background
   // layer (solid colors, insets, effects), so the runtime skips its Background.
   if (fullMeta.background) {
@@ -277,12 +118,12 @@ export function extractRuntimeSchema(fullMeta, dataSchemaMap = {}) {
   // data: it maps each `content.data` key to its schema. A value is a named ref
   // (`'@/member'`), an inline field map, or an inline rich-form (`{ fields: [...] }`,
   // an editor form). Source-agnostic — the data may arrive by fetch, tagged code
-  // block, or editor form; the schema and its defaults are identical.
+  // block, or editor form, and it reaches the component as it arrived.
   //
-  // ⭐ Every key reaches the runtime, a key with no fields included — `data` lists them
-  // with their refs, because the keys ARE what the section receives, and a key's ref is
-  // what a fetch of another name fills it by. `schemas` carries field defaults for the
-  // keys that have fields. `data: false` declares nothing, as no `data:` does.
+  // ⭐ Every key reaches the runtime — `data` lists them with their refs, because the keys
+  // ARE what the section receives, and a key's ref is what a fetch of another name fills
+  // it by. Its shape stays in schema.json, for the editor. `data: false` declares nothing,
+  // as no `data:` does.
   //
   // ⭐ A concept block's key is written as its fence is — `'md:faq': 'Questions and
   // answers'` — and lowered to the key a component reads, `faq`, with no schema: the value
@@ -308,11 +149,6 @@ export function extractRuntimeSchema(fullMeta, dataSchemaMap = {}) {
       }
       runtime.data = runtime.data || {}
       runtime.data[key] = dataRef(value)
-      const lean = leanDataSchema(value, dataSchemaMap)
-      if (lean) {
-        runtime.schemas = runtime.schemas || {}
-        runtime.schemas[key] = lean
-      }
     }
   } else if (data !== undefined) {
     throw new Error(
@@ -321,6 +157,11 @@ export function extractRuntimeSchema(fullMeta, dataSchemaMap = {}) {
     )
   }
 
+  const vars = leanComponentVars(fullMeta.vars)
+  if (vars) {
+    runtime.vars = vars
+  }
+
   const paramsObj = fullMeta.params
   const defaults = extractParamDefaults(paramsObj)
   if (defaults) {
@@ -339,9 +180,6 @@ export function extractRuntimeSchema(fullMeta, dataSchemaMap = {}) {
     runtime.initialState = fullMeta.initialState
   }
 
-  // (Top-level `schemas:` is gone — inline field maps and rich-forms are now
-  // just `data:` entries with an inline value. See leanDataSchema.)
-
   return Object.keys(runtime).length > 0 ? runtime : null
 }
 
@@ -351,11 +189,11 @@ export function extractRuntimeSchema(fullMeta, dataSchemaMap = {}) {
  * @param {Object} componentsMeta - Map of componentName -> meta.js content
  * @returns {Object} - Map of componentName -> runtime schema (excludes null entries)
  */
-export function extractAllRuntimeSchemas(componentsMeta, dataSchemaMap = {}) {
+export function extractAllRuntimeSchemas(componentsMeta) {
   const schemas = {}
 
   for (const [name, meta] of Object.entries(componentsMeta)) {
-    const schema = extractRuntimeSchema(meta, dataSchemaMap)
+    const schema = extractRuntimeSchema(meta)
     if (schema) {
       schemas[name] = schema
     }
@@ -368,7 +206,6 @@ export function extractAllRuntimeSchemas(componentsMeta, dataSchemaMap = {}) {
  * Extract lean runtime schema for a layout from its full meta.js
  *
  * Layout runtime metadata:
- * - areas: Array of area names this layout supports
  * - transitions: View transition name overrides (the runtime auto-names areas;
  *   this overrides per region, or `false` opts the layout out)
  * - defaults: Param default values
@@ -385,9 +222,8 @@ export function extractLayoutRuntimeSchema(fullMeta) {
 
   const runtime = {}
 
-  if (fullMeta.areas && Array.isArray(fullMeta.areas)) {
-    runtime.areas = fullMeta.areas
-  }
+  // ⛔ No `areas`: the areas a page renders are its site's `layout/` folder
+  // (`Website.getLayoutAreas`), and a layout's list of them is for the editor.
 
   // `false` is a value, not an absence: it is the documented way a layout opts
   // out of per-area view transitions. The previous guard was

package/src/uwx/data-schema.js

@@ -112,7 +112,7 @@ export function isContentBodyField(field) {
  * @param {(ref: string) => string} [opts.resolveOptions] - maps an `options`
  *   (item_ref) ref to its full `@org/model/<section>` path. Falls back to
  *   `resolveName` (model only) when not supplied.
- * @returns {Object} the declaration (`{ name, label?, plural?, description?,
+ * @returns {Object} the declaration (`{ name, label?, plural?, icon?, description?,
  *          source_locale?, linkable?, sections }`).
  */
 export function toDataSchemaDeclaration(normalized, { name, resolveName, resolveOptions } = {}) {
@@ -137,6 +137,9 @@ export function toDataSchemaDeclaration(normalized, { name, resolveName, resolve
   const decl = { name }
   if (normalized.label) decl.label = normalized.label
   if (normalized.plural) decl.plural = normalized.plural
+  // The type's icon — a framework icon name (`lu-user`), sent as written; the registry
+  // stores it verbatim and a consumer resolves it. Since 2026-10-05 [Diego].
+  if (normalized.icon) decl.icon = normalized.icon
   if (normalized.description) decl.description = normalized.description
   if (normalized.sourceLocale) decl.source_locale = normalized.sourceLocale
   // ⛔ No `creatable_by`: retired 2026-09-23 — Models are open, and `@uniweb/schemas`
@@ -451,8 +454,10 @@ function lowerLeaf(field, resolve, optResolve, { multiple = false } = {}) {
   if (Array.isArray(field.enum)) out.enum = field.enum
   if (leafFormat) out.format = leafFormat
 
-  // `default` is intentionally NOT emitted — it rides in the foundation-schema
-  // blob (render / editor pre-fill), not the content type.
+  // No `default`: a named schema declares none (`resolve-data-schema.js` refuses one, since
+  // 2026-10-05). ⛔ This said it "rides in the foundation-schema blob (render / editor
+  // pre-fill)" until then — but that blob leaves `dataSchemas` out, so a named schema's
+  // default reached the runtime alone, and no editor.
   return out
 }