@uniweb/build 0.74.4 → 0.75.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.74.4",
+  "version": "0.75.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -58,14 +58,14 @@
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
     "@uniweb/content-reader": "^1.2.8",
-    "@uniweb/projections": "^0.7.11",
-    "@uniweb/theming": "^0.2.0",
     "@uniweb/content-writer": "^0.3.4",
-    "@uniweb/schemas": "^0.10.1",
+    "@uniweb/projections": "^0.7.13",
+    "@uniweb/schemas": "^0.10.2",
+    "@uniweb/theming": "^0.2.0",
     "@uniweb/semantic-parser": "^1.5.1"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.28.7"
+    "@uniweb/runtime": "^0.28.10"
   },
   "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.35.2",
-    "@uniweb/runtime": "^0.28.7"
+    "@uniweb/core": "^0.36.0",
+    "@uniweb/runtime": "^0.28.10"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/generate-entry.js

@@ -5,7 +5,8 @@
  *
  * Exports:
  * - `components` - Object map of component name -> React component
- * - `capabilities` - Custom Layout and props from src/main.js (if present)
+ * - `capabilities` - what the runtime reads of src/main.js (`extractFoundationRuntime`): the
+ *   code it calls, referenced from the module, and its data, lean — plus the discovered layouts
  * - `meta` - Per-component runtime metadata extracted from meta.js files
  *
  * The `meta` export contains only properties needed at runtime:
@@ -26,10 +27,11 @@ import { join, dirname } from 'node:path'
 import {
   discoverComponents,
   discoverLayoutsInPath,
+  loadFoundationConfig,
   DEFAULT_SECTION_PATHS,
   LAYOUTS_PATH
 } from './schema.js'
-import { extractAllRuntimeSchemas, extractAllLayoutRuntimeSchemas } from './runtime-schema.js'
+import { extractAllRuntimeSchemas, extractAllLayoutRuntimeSchemas, extractFoundationRuntime } from './runtime-schema.js'
 import { collectSchemaRefs, buildDataSchemaMap, SCHEMA_EXTENSIONS } from './resolve-data-schema.js'
 
 /**
@@ -88,31 +90,12 @@ async function detectHostShareableImports(srcDir) {
 }
 
 /**
- * Detect foundation config file (for props, vars, etc.)
- *
- * Looks for (in priority order): main.js, main.jsx
- *
- * The foundation's main authored module.
- *
- * The file should export:
- * - props (optional) - Foundation-wide props
- * - vars (optional) - CSS custom properties (also read by schema builder)
- * - defaultLayout (optional) - Default layout name
- *
- * Note: Layout components are now discovered from layouts/ at the source root.
+ * The foundation's `main.js` — its declarations, read by `loadFoundationConfig` as the schema
+ * reads them. `main.js` is the only name: ⛔ until 2026-10-01 this also took a `main.jsx`, which
+ * nothing else read, so the editor saw none of its declarations while the runtime saw all of them.
  */
 function detectFoundationExports(srcDir) {
-  const candidates = [
-    { path: 'main.js', ext: 'js' },
-    { path: 'main.jsx', ext: 'jsx' },
-  ]
-
-  for (const { path, ext } of candidates) {
-    if (existsSync(join(srcDir, path))) {
-      return { path: `./${path}`, ext }
-    }
-  }
-  return null
+  return existsSync(join(srcDir, 'main.js')) ? { path: './main.js', ext: 'js' } : null
 }
 
 /**
@@ -140,6 +123,7 @@ function generateEntrySource(components, options = {}) {
   const {
     cssPath = null,
     foundationExports = null,
+    foundationRuntime = { code: [], data: {} },
     meta = {},
     layouts = {},
     layoutMeta = {},
@@ -160,10 +144,15 @@ function generateEntrySource(components, options = {}) {
     lines.push(`import '${cssPath}'`)
   }
 
-  // Foundation capabilities import (for props, vars, etc.)
-  // Note: Layout/layouts no longer merged from main.js — layouts come from src/layouts/ discovery
+  // The foundation's `main.js` — imported for the code the runtime calls, and only referenced for
+  // it, so the bundler drops the rest of its default export (measured 2026-10-01). With no such
+  // code, imported for its side effects alone. Its data is written below, lean.
   if (foundationExports) {
-    lines.push(`import * as _foundationModule from '${foundationExports.path}'`)
+    lines.push(
+      foundationRuntime.code.length > 0
+        ? `import * as _foundationModule from '${foundationExports.path}'`
+        : `import '${foundationExports.path}'`
+    )
   }
 
   // Component imports
@@ -185,21 +174,19 @@ function generateEntrySource(components, options = {}) {
     lines.push(`export { ${componentNames.join(', ')} }`)
   }
 
-  // Foundation capabilities (props, vars, etc. + discovered layouts)
+  // Foundation capabilities — what the runtime reads of `main.js`, and nothing else of it
+  // (`extractFoundationRuntime`, ruled 2026-10-01 [Diego]): the code it calls, referenced from the
+  // module, and its data as a lean literal — `vars` (each var's `default`, `type`, `applyTo`, as
+  // `loadFoundationConfig` reads them, named export first), `data` (each key's schema ref), and the
+  // defaults that pick a layout, a section type, transitions and scroll. Plus the discovered layouts.
+  // ⛔ Until 2026-10-01 the whole default export was spread in, so a foundation's name, description
+  // and its vars' descriptions shipped in every published bundle.
   lines.push('')
   if (foundationExports || layoutNames.length > 0) {
     const capParts = []
     if (foundationExports) {
-      capParts.push('..._foundationModule.default')
-      // `vars` is a NAMED export of main.js, so the spread above misses it —
-      // schema.js reads `module.vars || module.default?.vars` and this must
-      // agree with it (named wins), or the runtime and the editor would see
-      // different foundation vars. Without this line the declared theme vars
-      // exist ONLY in dist/meta/schema.json, which is a build-time artifact:
-      // any lane that generates theme CSS outside the build (the runtime's
-      // ensureThemeCss, a cloud shell assembler) would silently produce a
-      // theme missing every foundation-declared var.
-      capParts.push('vars: _foundationModule.vars || _foundationModule.default?.vars')
+      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)}`)
     }
     if (layoutNames.length > 0) {
       capParts.push(`layouts: { ${layoutNames.join(', ')} }`)
@@ -316,8 +303,13 @@ export async function generateEntryPoint(srcDir, outputPath = null, options = {}
   // Check for CSS file
   const cssPath = detectCssFile(srcDir)
 
-  // Check for foundation exports (props, vars, etc.)
+  // The foundation's `main.js`, and what the runtime reads of it — read as the schema reads it
+  // (`loadFoundationConfig`: the named `vars` first, JSX imports transpiled), so the editor and the
+  // runtime see one declaration.
+  // Asked even with no main.js: it refuses a `foundation.js` or `main.jsx` left in its place.
   const foundationExports = detectFoundationExports(srcDir)
+  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
@@ -347,6 +339,7 @@ export async function generateEntryPoint(srcDir, outputPath = null, options = {}
   const source = generateEntrySource(components, {
     cssPath,
     foundationExports,
+    foundationRuntime,
     meta,
     layouts,
     layoutMeta,
@@ -386,6 +379,7 @@ export async function generateEntryPoint(srcDir, outputPath = null, options = {}
     componentNames,
     layoutNames,
     foundationExports,
+    foundationRuntime,
     meta,
     layoutMeta,
     hostShareableImports,

package/src/i18n/audit.js

@@ -10,6 +10,7 @@
 import { readFile, writeFile } from 'fs/promises'
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
+import { translationKeepsMarkup } from './merge.js'
 
 // Inline markdown → ProseMirror, so the markup check asks the merge's own question
 // ("would this value produce marks?") instead of pattern-matching markdown syntax.
@@ -67,16 +68,18 @@ export async function auditLocale(localesPath, locale) {
       const translation = getTranslationText(translations[hash])
       valid.push({ hash, source, translation })
 
-      // ⭐ The source element carries inline markdown; the translation does not.
-      // `merge` builds the translated element from the VALUE alone — it never
-      // re-applies marks from the source — so this entry will render as flat prose
-      // and its links will be gone. It still counts as translated, which is why
-      // coverage cannot see it: the whole class scores 100%.
+      // ⭐ The source element carries inline markdown, and what the merge makes of
+      // the translation does not — so this entry will render as flat prose and its
+      // links will be gone. It still counts as translated, which is why coverage
+      // cannot see it: the whole class scores 100%. The merge's own answer
+      // (`translationKeepsMarkup`): a plain label for a button keeps its link there,
+      // so it is no loss. ⛔ Until 2026-10-01 any plain value counted, when the merge
+      // rebuilt every element from the value alone.
       // ⛔ REPLACES a `<N>`-tag check that could no longer fire. Those tags were the
       // pre-2026-06-24 keying scheme (`d12d594`); extraction has not emitted one
       // since, so the check was dead while looking like a live guard — and it was
       // the only thing in the pipeline that even gestured at mark fidelity.
-      if (unit.markup && translation.length > 0 && !carriesInlineMarkup(translation)) {
+      if (unit.markup && translation.length > 0 && dropsSourceMarkup(unit.markup, translation)) {
         losesMarkup.push({ hash, source, markup: unit.markup, translation })
       }
     } else {
@@ -111,24 +114,19 @@ export async function auditLocale(localesPath, locale) {
 }
 
 /**
- * Does this translation value produce any inline marks when the merge parses it?
+ * Does the merge drop the inline markup this translation's source element carries?
  *
- * Asks the parser rather than a regex: the merge resolves a value through
- * `markdownToProseMirror`, so the only honest test of "will this keep its link"
- * is to run the same conversion. With no converter available the check declines
- * to fire — a missing dependency must not invent findings.
+ * Asks the merge rather than a regex (`translationKeepsMarkup`), since what the
+ * merge makes of a value is the only honest answer to "will this keep its link".
+ * With no converter available the check declines to fire — a missing dependency
+ * must not invent findings.
  */
-function carriesInlineMarkup(value) {
-  if (!markdownToProseMirror) return true
+function dropsSourceMarkup(markup, value) {
+  if (!markdownToProseMirror) return false
   try {
-    const doc = markdownToProseMirror(value)
-    const walk = (nodes) =>
-      (nodes || []).some(
-        (n) => (n?.marks && n.marks.length > 0) || (n?.type && n.type !== 'text' && n.type !== 'paragraph') || walk(n?.content)
-      )
-    return walk(doc?.content)
+    return !translationKeepsMarkup(markup, value)
   } catch {
-    return true
+    return false
   }
 }
 

package/src/i18n/merge.js

@@ -345,16 +345,16 @@ function translateProseMirrorDoc(doc, context, translations, fallbackToSource) {
   return changed
 }
 
-// Replace one block element's inline content with the parsed translation
-// fragment. `lookupTranslation` with the already-trimmed key adds no surrounding
-// whitespace and returns the source on a miss, so `value === key` means
-// "no translation" → leave the element as-is. Returns true if it replaced.
+// Replace one block element's inline content with what its translation gives it
+// (`translatedInline`). `lookupTranslation` with the already-trimmed key adds no
+// surrounding whitespace and returns the source on a miss, so `value === key`
+// means "no translation" → leave the element as-is. Returns true if it replaced.
 function applyElementTranslation(node, context, translations, fallbackToSource) {
   const key = elementText(node)
   if (!key) return false
   const value = lookupTranslation(key, context, translations, fallbackToSource)
   if (value === key) return false
-  const fragment = inlineMarkdownToFragment(value)
+  const fragment = translatedInline(node.content, value)
   if (fragment && fragment.length) {
     node.content = fragment
     return true
@@ -362,6 +362,129 @@ function applyElementTranslation(node, context, translations, fallbackToSource)
   return false
 }
 
+/**
+ * ⭐ WHAT A TRANSLATION GIVES AN ELEMENT: its value, parsed as inline markdown — with one
+ * exception. A value that names no link, given to an element made only of links, is their
+ * LABELS: a button's translation is its label (`Créer un groupe`), and buttons on consecutive
+ * lines take one label per line. Each keeps its source link — its target and its attributes
+ * (`{role=primary icon=…}`), which are structure, not words.
+ *
+ * ⛔ Until 2026-10-01 the value replaced the element whole, so a label translated on its own lost
+ * its link: the button became a plain paragraph, or vanished from a section that renders only
+ * links. Locale files keyed before whole-element keying hold exactly such labels.
+ *
+ * A value that writes a link is taken as written, re-targeted or not. So is a plain value for an
+ * element that mixes words and links, since which words were linked cannot be known;
+ * `uniweb i18n status` reports that loss (`translationKeepsMarkup`).
+ *
+ * @param {Array} source - the element's source inline content
+ * @param {string} value - the translation, inline markdown
+ * @returns {Array|null} the translated inline content; null for an empty value
+ */
+export function translatedInline(source, value) {
+  const fragment = inlineMarkdownToFragment(value)
+  if (!fragment) return null
+  return asLinkLabels(source, fragment) || fragment
+}
+
+/**
+ * Does a translation keep the inline markup of its source element? The merge's own answer —
+ * what `translatedInline` makes of the value — so the audit can neither report a loss the merge
+ * does not make nor miss one it does.
+ *
+ * @param {string} markup - the source element's inline markdown (a manifest unit's `markup`)
+ * @param {string} value - the translation
+ * @returns {boolean}
+ */
+export function translationKeepsMarkup(markup, value) {
+  const result = translatedInline(inlineMarkdownToFragment(markup) || [], value) || []
+  return result.some((node) => node.type !== 'text' || (node.marks && node.marks.length > 0))
+}
+
+// The source's links with the fragment as their labels — the whole fragment for one link, a line
+// each for several — or null: the fragment names a link of its own, the source is not only links,
+// or the lines do not match the links one to one.
+function asLinkLabels(source, fragment) {
+  if (fragment.some((node) => linkMarkOf(node))) return null
+  const links = linkRuns(source)
+  if (!links) return null
+  const labels = links.length === 1 ? [trimInline(fragment)] : inlineLines(fragment)
+  if (labels.length !== links.length || labels.some((label) => !label.length)) return null
+  const out = []
+  links.forEach((link, i) => {
+    if (i > 0) out.push(...link.before)
+    for (const node of labels[i]) out.push(withMarks(node, link.marks))
+  })
+  return out
+}
+
+// An element made only of links, as its runs: each link's marks (those all its text shares) and
+// the line breaks or spaces before it. Null when anything else is in it — words outside a link,
+// an icon, an image.
+function linkRuns(source) {
+  const runs = []
+  let gap = []
+  for (const node of source || []) {
+    if (!node) continue
+    const link = linkMarkOf(node)
+    if (link) {
+      const last = runs[runs.length - 1]
+      if (last && !gap.length && sameMark(last.link, link)) {
+        last.marks = last.marks.filter((mark) => node.marks.some((own) => sameMark(own, mark)))
+      } else {
+        runs.push({ link, marks: [...node.marks], before: gap })
+      }
+      gap = []
+    } else if (node.type === 'hardBreak' || (node.type === 'text' && !node.marks?.length && !node.text?.trim())) {
+      gap.push(node)
+    } else {
+      return null
+    }
+  }
+  return runs.length ? runs : null
+}
+
+function linkMarkOf(node) {
+  return node?.type === 'text' ? node.marks?.find((mark) => mark.type === 'link') || null : null
+}
+
+function sameMark(a, b) {
+  return Boolean(a && b) && a.type === b.type && JSON.stringify(a.attrs || {}) === JSON.stringify(b.attrs || {})
+}
+
+// A fragment's lines, split at line breaks, each trimmed; blank lines dropped.
+function inlineLines(fragment) {
+  const lines = [[]]
+  for (const node of fragment) {
+    if (node.type === 'hardBreak') {
+      lines.push([])
+    } else if (node.type === 'text' && node.text.includes('\n')) {
+      node.text.split('\n').forEach((part, i) => {
+        if (i > 0) lines.push([])
+        if (part) lines[lines.length - 1].push({ ...node, text: part })
+      })
+    } else {
+      lines[lines.length - 1].push(node)
+    }
+  }
+  return lines.map(trimInline).filter((line) => line.length)
+}
+
+// Leading and trailing whitespace off a run of inline nodes.
+function trimInline(nodes) {
+  const out = nodes.map((node) => ({ ...node }))
+  if (out[0]?.type === 'text') out[0].text = out[0].text.replace(/^\s+/, '')
+  const last = out[out.length - 1]
+  if (last?.type === 'text') last.text = last.text.replace(/\s+$/, '')
+  return out.filter((node) => node.type !== 'text' || node.text)
+}
+
+// A label node with its link's marks; a mark of its own of another type stays.
+function withMarks(node, marks) {
+  const own = (node.marks || []).filter((mark) => !marks.some((linkMark) => linkMark.type === mark.type))
+  return { ...node, marks: [...marks, ...own] }
+}
+
 /**
  * Translate the human-readable strings inside a section's TAGGED DATA BLOCKS,
  * in place. The other half of the fix in `extract.js` — a manifest entry nobody

package/src/runtime-schema.js

@@ -434,3 +434,87 @@ export function extractAllLayoutRuntimeSchemas(layoutsMeta) {
 
   return schemas
 }
+
+/**
+ * ⭐ WHAT THE RUNTIME READS OF A FOUNDATION'S `main.js` — and nothing else of it. Ruled
+ * 2026-10-01 [Diego]: *"Only what runtime really reads for rendering should reach it."*
+ *
+ * Read off every runtime reader of the entry's `capabilities` (2026-10-01): core's `Uniweb` and
+ * `Website`, the runtime's wiring, navigation and scroll, `@uniweb/theming`, kit's xref, the
+ * fetch dispatcher, and press. Two kinds:
+ *
+ *   code  `handlers`, `defaultInsets`, `xref`, `transports`, `outputs` — functions and
+ *         components, so the entry REFERENCES each from the module and the bundler drops the rest
+ *         of `main.js`'s default export.
+ *   data  `defaultLayout`, `defaultSection`, `viewTransitions`, `scroll`; `vars`, each var's
+ *         `default`, `type` and `applyTo` — all `@uniweb/theming` reads; `data`, each key's schema
+ *         ref — all `declaredKeys` reads. Written as a literal, like a section type's lean schema.
+ *
+ * ⛔ Never: `name`, `description`, `extension`, a var's label or description, a data key's shape,
+ * or any key the framework does not read. ⛔ Until 2026-10-01 the entry spread the whole default
+ * export into `capabilities`, and a foundation's name and its vars' descriptions shipped in every
+ * published bundle.
+ *
+ * A data key whose value is not plain data (a function, say) is referenced like code, so nothing
+ * is lost to serialization.
+ *
+ * @param {Object} config - the foundation's `main.js`, as `loadFoundationConfig` reads it
+ * @returns {{ code: string[], data: Object }} the code keys to reference, and the data to inline
+ */
+export function extractFoundationRuntime(config = {}) {
+  const code = RUNTIME_CODE_CAPABILITIES.filter((key) => config?.[key] !== undefined)
+  const data = {}
+  for (const key of RUNTIME_DATA_CAPABILITIES) {
+    const value = config?.[key]
+    if (value === undefined) continue
+    if (isPlainData(value)) data[key] = value
+    else code.push(key)
+  }
+  const vars = leanVars(config?.vars)
+  if (vars) data.vars = vars
+  const keys = leanDataKeys(config?.data)
+  if (keys) data.data = keys
+  return { code, data }
+}
+
+/** The `main.js` capabilities the runtime calls or renders — referenced, never copied. */
+export const RUNTIME_CODE_CAPABILITIES = ['handlers', 'defaultInsets', 'xref', 'transports', 'outputs']
+
+/** The `main.js` values the runtime reads as data — written into the entry. */
+const RUNTIME_DATA_CAPABILITIES = ['defaultLayout', 'defaultSection', 'viewTransitions', 'scroll']
+
+/** What `@uniweb/theming` reads of a foundation var: its value, its kind, and a font role's selectors. */
+const RUNTIME_VAR_FIELDS = ['default', 'type', 'applyTo']
+
+function leanVars(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)) {
+      const lean = {}
+      for (const field of RUNTIME_VAR_FIELDS) if (config[field] !== undefined) lean[field] = config[field]
+      out[name] = lean
+    } else {
+      out[name] = config
+    }
+  }
+  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. */
+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)
+  return Object.keys(out).length > 0 ? out : null
+}
+
+function isPlainData(value) {
+  if (value === null || ['string', 'number', 'boolean'].includes(typeof value)) return true
+  if (Array.isArray(value)) return value.every(isPlainData)
+  if (typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.values(value).every(isPlainData)
+  }
+  return false
+}

package/src/schema.js

@@ -18,6 +18,7 @@ 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 { SECTION_PARAMS, SECTION_KEYS } from '@uniweb/schemas/section'
 import { collectSchemaRefs, buildDataSchemaMap, ownSchemaRefs } from './resolve-data-schema.js'
 import {
@@ -298,7 +299,6 @@ function retiredScopeMessage(pkgPath, scope, name) {
  * Contains foundation-wide configuration:
  * - vars: CSS custom properties sites can override
  * - defaultLayout: Default layout name
- * - props: Foundation-wide props
  * - Future: providers, middleware, etc.
  */
 /**
@@ -315,7 +315,6 @@ const DEFAULT_ONLY_CAPABILITIES = [
   'defaultLayout',
   'defaultSection',
   'viewTransitions',
-  'props',
   'defaultInsets',
   'xref',
   'outputs',
@@ -328,8 +327,9 @@ const DEFAULT_ONLY_CAPABILITIES = [
 /**
  * Warn when a capability was written as a named export.
  *
- * `generate-entry.js` builds `capabilities` as `{ ..._foundationModule.default,
- * vars: … }` — it spreads only the DEFAULT export. A named `export const xref =
+ * `generate-entry.js` builds `capabilities` from the DEFAULT export only — the code the
+ * runtime calls, referenced, and its data, lean (`extractFoundationRuntime`; until
+ * 2026-10-01 it spread the whole default export). A named `export const xref =
  * …` is therefore dropped with no error, no warning, and a build that succeeds.
  * Whatever the capability did simply does not happen, which reads as "the
  * feature is not implemented" rather than "it is declared in the wrong place".
@@ -474,10 +474,20 @@ export async function loadFoundationConfig(srcDir) {
     if (existsSync(legacy)) {
       throw new Error(
         `${legacy} is no longer read — rename it to main.js.\n` +
-          `  A foundation's declarations (vars, defaultLayout, defaultSection, props, name) live in\n` +
+          `  A foundation's declarations (vars, defaultLayout, defaultSection, name) live in\n` +
           `  main.js. Left as foundation.js, the build would continue with none of them.`,
       )
     }
+    // ⛔ The same for `main.jsx`, which the entry used to import while this read nothing — the
+    // editor saw none of its declarations, the runtime all of them (until 2026-10-01). A main.js
+    // may hold JSX: `importFoundationConfig` transpiles it.
+    const jsx = join(srcDir, 'main.jsx')
+    if (existsSync(jsx)) {
+      throw new Error(
+        `${jsx} is not read — rename it to main.js, which may hold JSX.\n` +
+          `  A foundation's declarations live in main.js; left as main.jsx, the build would continue with none of them.`,
+      )
+    }
     return {}
   }
 
@@ -612,8 +622,12 @@ function buildComponentEntry(name, relativePath, meta) {
     path: relativePath,
   }
 
+  // ⭐ `[]` says the component TAKES NO CONTENT — `content: {}` or `content: []` in its `meta.js`
+  // [Diego, 2026-10-01] — a component that only reads `content.data`, say. Absent says it
+  // declared nothing, which is unknown. ⛔ Until 2026-10-01 both came out absent.
   const content = describeContent(meta)
   if (content.elements.length > 0) entry.content = content.elements
+  else if (declaresNoContent(meta.content)) entry.content = []
   else delete entry.content
 
   const children = lowerChildren(meta)
@@ -627,6 +641,12 @@ function buildComponentEntry(name, relativePath, meta) {
   return entry
 }
 
+/** `content: {}` or `content: []` — the component's way of saying it takes no content. */
+function declaresNoContent(content) {
+  if (Array.isArray(content)) return content.length === 0
+  return content !== null && typeof content === 'object' && Object.keys(content).length === 0
+}
+
 /**
  * Refuse a declaration that was retired, naming what replaces it. A refusal, not a
  * warning: a retired key would otherwise register as if it still meant something.
@@ -1010,6 +1030,31 @@ function reportSupports(srcDir, authored, derived, emitted) {
   }
 }
 
+/**
+ * Warn of a `data:` value `register` will refuse — one the normalized form it sends cannot
+ * write (`@uniweb/schemas/foundation`): an inline field map that is not a valid data schema.
+ * The build goes on; the site renders the map as before. `register` is where it stops, since
+ * a registered schema is written in one spelling per meaning or not at all.
+ *
+ * @param {Object} components - discovered section types, by name
+ * @param {Object} [layouts] - discovered layouts, by name
+ * @param {Object} [foundationConfig] - the foundation's `main.js`, whose `data:` reaches every section
+ */
+export function reportUnregistrableData(components, layouts = {}, foundationConfig = {}) {
+  const owners = [
+    ...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)', foundationConfig?.data],
+  ]
+  for (const [owner, data] of owners) {
+    try {
+      normalizeData(data, { owner })
+    } catch (err) {
+      console.warn(`Warning: ${err.message} \`uniweb register\` refuses it until it is one.`)
+    }
+  }
+}
+
 /**
  * Warn about `content` and `children` declarations an editor cannot use — what lowering
  * them could not read (`@uniweb/schemas`, the grammar the editor reads them with). The
@@ -1109,6 +1154,7 @@ export async function buildSchema(srcDir, sectionPaths, derivedSupports = null)
 
   // Discover layouts from src/layouts/
   const layouts = await discoverLayoutsInPath(srcDir)
+  reportUnregistrableData(components, layouts, foundationConfig)
 
   // Determine extension role
   const isExtension = !!foundationConfig.extension

package/src/site/config.js

@@ -36,6 +36,7 @@ import { checkFoundationResolution } from '../utils/foundation-resolution-check.
 import { detectFoundationType } from './foundation-ref.js'
 import { readPreview, PREVIEW_ENV } from './preview.js'
 import { previewMediaPlugin } from './preview-media.js'
+import { previewDirectoryIndexPlugin } from './preview-directory-index.js'
 
 /**
  * Normalize a base path for Vite compatibility
@@ -396,6 +397,9 @@ export async function defineSiteConfig(options = {}) {
 
   if (noopFoundationPlugin) plugins.push(noopFoundationPlugin)
 
+  // `vite preview` answers `/about` with `about/index.html`, as the hosts a build deploys to do.
+  plugins.push(previewDirectoryIndexPlugin())
+
   // Import map plugin for runtime mode production builds.
   // Emits re-export modules for each externalized package (react, @uniweb/core, etc.)
   // so the browser can resolve bare specifiers in the dynamically-imported foundation.

package/src/site/preview-directory-index.js

@@ -0,0 +1,67 @@
+/**
+ * ⭐ `vite preview` SERVES A PAGE'S FOLDER FOR ITS URL WITHOUT THE SLASH — as the hosts a site
+ * deploys to do. A build writes each page as `<route>/index.html`, and GitHub Pages, Cloudflare
+ * Pages, Netlify and Vercel answer `/fr/a-propos` with `fr/a-propos/index.html` (the S3 + CloudFront
+ * adapter ships a function for it, `../hosts/s3-cloudfront.js`).
+ *
+ * `vite preview` answers it with the site's ROOT document instead: its SPA fallback serves
+ * `index.html` for any path with no file of its own. That document carries the default locale's
+ * content, so a translated page asked for without the slash rendered the not-found page once the
+ * runtime took over — the French URL resolved against English content — and every other page got
+ * the home page's prerender under its own URL. ⛔ So until 2026-10-01 the preview of a build showed
+ * what no host it deploys to does.
+ *
+ * Only an existing folder with an `index.html` is answered, and a `<route>.html` beside it wins, as
+ * on those hosts. Everything else goes to Vite unchanged.
+ */
+import { existsSync, statSync } from 'node:fs'
+import { join, resolve, sep } from 'node:path'
+
+/**
+ * The URL `vite preview` should serve for a request: its folder's `index.html`, or null to leave the
+ * request alone.
+ *
+ * @param {{ method?: string, url?: string }} req
+ * @param {string} outDir - the build's output directory, absolute
+ * @param {string} [base] - the site's deployment base (`/`, `/docs/`)
+ * @returns {string|null}
+ */
+export function directoryIndexUrl(req, outDir, base = '/') {
+  if (req.method !== 'GET' && req.method !== 'HEAD') return null
+  const url = req.url || ''
+  const queryAt = url.indexOf('?')
+  const pathname = queryAt === -1 ? url : url.slice(0, queryAt)
+  const query = queryAt === -1 ? '' : url.slice(queryAt)
+
+  const mount = base.endsWith('/') ? base : `${base}/`
+  if (pathname.endsWith('/') || !pathname.startsWith(mount)) return null
+
+  let route
+  try {
+    route = decodeURIComponent(pathname.slice(mount.length - 1))
+  } catch {
+    return null
+  }
+
+  const dir = join(outDir, route)
+  if (dir !== outDir && !dir.startsWith(outDir + sep)) return null
+  if (existsSync(`${dir}.html`)) return null
+  if (!existsSync(join(dir, 'index.html')) || !statSync(dir).isDirectory()) return null
+  return `${pathname}/index.html${query}`
+}
+
+/** The plugin: a middleware ahead of Vite's own, in `vite preview` only. */
+export function previewDirectoryIndexPlugin() {
+  return {
+    name: 'uniweb:preview-directory-index',
+    configurePreviewServer(server) {
+      const { root, base, build } = server.config
+      const outDir = resolve(root, build.outDir)
+      server.middlewares.use((req, _res, next) => {
+        const target = directoryIndexUrl(req, outDir, base)
+        if (target) req.url = target
+        next()
+      })
+    },
+  }
+}

package/src/uwx/registry-package.js

@@ -26,6 +26,7 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 
+import { normalizeFoundationSchema } from '@uniweb/schemas/foundation'
 import { toDataSchemaDeclaration, SHORTHAND_SECTION } from './data-schema.js'
 import { checkFoundationName, splitFoundationName } from '../foundation-name.js'
 
@@ -81,7 +82,7 @@ export function buildRegistryPackage({ schema, foundationDir, scope, exporter, e
   const foundationEntity = {
     model: FOUNDATION_SCHEMA,
     info: buildInfo(self, org, digest, runtime),
-    schema: buildSchemaBlob(schema),
+    schema: buildSchemaBlob(schema, org),
     i18n: { locales: loadI18nLocales(foundationDir) },
     'data-schemas': { refs: buildRefs(dataSchemas, scoped) },
   }
@@ -250,16 +251,27 @@ function buildInfo(self, org, digest, runtime) {
   return info
 }
 
-// The whole renderable schema.json MINUS identity and MINUS dataSchemas, shipped
-// as one opaque object the backend never reads into (custodian).
-function buildSchemaBlob(schema) {
+// The foundation schema an editor reads: the whole renderable schema.json MINUS identity
+// and MINUS dataSchemas, shipped as one object the backend stores and serves, and never
+// reads into (custodian).
+//
+// ⭐ IN ITS NORMALIZED FORM — `schemaFormat: 3` (`@uniweb/schemas/foundation`, ruled
+// 2026-10-01 [Diego]): every entry in one spelling per meaning, so the editor needs no
+// framework grammar, and each `@/x` a `data:` key names qualified with the scope the
+// foundation registers under — the name its Model was stored under. ⛔ Until 2026-10-01 the
+// build's format 2 shipped as built, and `data: { team: '@/member' }` reached the editor
+// as written. `dist/meta/schema.json` stays format 2: the build's own readers read it.
+//
+// It throws for a `data:` value that cannot be normalized — an inline field map that is
+// not a valid data schema — naming the component and the key; the build warns of it first.
+function buildSchemaBlob(schema, org) {
   const { dataSchemas: _ds, ...rest } = schema
   // Every key hoisted into `info` is stripped here, so the wire carries each
   // fact ONCE. Two copies of one fact is a drift liability, and the copy inside
   // an opaque blob is the one nobody would think to update.
   const { name: _n, version: _v, description: _d, role: _r, supports: _s, ...selfConfig } =
     rest._self || {}
-  return { ...rest, _self: selfConfig }
+  return normalizeFoundationSchema({ ...rest, _self: selfConfig }, { scope: org || undefined })
 }
 
 // The data-schemas the foundation renders, by NAME (own + shared), sorted.