@uniweb/build 0.74.4 → 0.75.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.74.4",
+  "version": "0.75.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/content-reader": "^1.2.8",
-    "@uniweb/projections": "^0.7.11",
-    "@uniweb/theming": "^0.2.0",
+    "@uniweb/projections": "^0.7.13",
     "@uniweb/content-writer": "^0.3.4",
-    "@uniweb/schemas": "^0.10.1",
-    "@uniweb/semantic-parser": "^1.5.1"
+    "@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.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/runtime": "^0.28.10",
+    "@uniweb/core": "^0.36.0"
   },
   "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/data-models.js

@@ -0,0 +1,77 @@
+/**
+ * ⭐ WHAT A SECTION TYPE SAYS ITS DATA BLOCKS ARE. A tagged data block (```yaml:logos) feeds the
+ * data key of its tag, and the section's type declares that key in its `meta.js` `data:` — a data
+ * schema ref (`'@/member'`), an inline field map (`{ name: 'string', style: { type: 'string', enum:
+ * [...] } }`), or nothing said (`{}`). The foundation's `main.js` `data:` reaches every section, and
+ * a key both declare is the section type's (`@uniweb/core/data-keys::declaredKeys`).
+ *
+ * This is the model of each declared shape, lowered by the push's own rule (`records.js::modelOf`),
+ * so the fields a block translates are the ones its model marks `localized`
+ * (`data-strings.js::visitDataBlockStrings`). Every form of a declaration is read by the one
+ * normalizer (`@uniweb/schemas/foundation::normalizeData`); a ref resolves as a query's records
+ * resolve theirs (`resolveRecordSchemas`). A key with no shape, or a ref that does not resolve, has
+ * no model, and its blocks keep the heuristic.
+ */
+import { normalizeData } from '@uniweb/schemas/foundation'
+import { foundationSections, resolveRecordSchemas } from '../site/queries-config.js'
+import { modelOf } from './records.js'
+
+/** The lookup when there is no foundation to ask: every block keeps the heuristic. */
+export const NO_DATA_MODELS = () => null
+
+/**
+ * The lookup for a site: `(sectionType, tag) => model | null`.
+ *
+ * @param {string} siteRoot
+ * @param {object} [siteYml] - an already-read site.yml
+ * @returns {Promise<(type: string, tag: string) => object|null>}
+ */
+export async function dataBlockModels(siteRoot, siteYml = null) {
+  let sections
+  try {
+    sections = await foundationSections(siteRoot, siteYml)
+  } catch {
+    return NO_DATA_MODELS
+  }
+  if (!sections || typeof sections !== 'object') return NO_DATA_MODELS
+
+  // Each declared key, by who declares it: a section type by name, the foundation as ''.
+  const declared = new Map()
+  const declare = (owner, data) => {
+    const normalized = normalizeData(data, { strict: false })
+    for (const [key, decl] of Object.entries(normalized || {})) declared.set(at(owner, key), decl)
+  }
+  for (const [name, entry] of Object.entries(sections)) {
+    if (!entry || typeof entry !== 'object' || name === 'dataSchemas' || name === '_layouts') continue
+    if (name === '_self') declare('', entry.data)
+    else if (!name.startsWith('_')) declare(name, entry.data)
+  }
+  if (!declared.size) return NO_DATA_MODELS
+
+  const refs = [...declared.values()].filter((d) => d.kind === 'schema').map((d) => d.schema)
+  let resolved = {}
+  if (refs.length) {
+    try {
+      resolved = (await resolveRecordSchemas(siteRoot, refs, { siteYml })).schemas || {}
+    } catch {
+      resolved = {}
+    }
+  }
+
+  const models = new Map()
+  for (const [where, decl] of declared) {
+    if (decl.kind === 'schema') models.set(where, modelOf(resolved[decl.schema] || null, decl.schema))
+    else if (decl.kind === 'fields') {
+      const { kind: _kind, problems: _problems, ...schema } = decl
+      models.set(where, modelOf(schema, '@/inline'))
+    } else models.set(where, null)
+  }
+
+  return (type, tag) => {
+    if (!tag) return null
+    if (type && models.has(at(type, tag))) return models.get(at(type, tag)) || null
+    return models.get(at('', tag)) || null
+  }
+}
+
+const at = (owner, key) => `${owner}\u0000${key}`

package/src/i18n/data-strings.js

@@ -19,6 +19,8 @@
  * missed field shows up as untranslated content nobody notices.
  */
 
+import { visitModelStrings } from './model-fields.js'
+
 /** Types that are never translatable regardless of schema. */
 export const NON_TRANSLATABLE_TYPES = new Set([
   'number', 'boolean', 'date', 'datetime', 'url', 'email', 'image'
@@ -112,3 +114,28 @@ export function visitDataStrings(data, visit, path = '', depth = 0) {
     // numbers and booleans are never prose
   }
 }
+
+/**
+ * ⭐ A TAGGED DATA BLOCK'S STRINGS, BY ITS DECLARED SHAPE WHEN IT HAS ONE. A section type that
+ * declares the shape of the key a block is tagged with — `data: { logos: { name: 'string', style:
+ * { type: 'string', enum: [...] } } }`, or a data schema ref — says which of its fields are text,
+ * and that is what is walked: the fields its model marks `localized`, the push's own rule
+ * (`model-fields.js`). An enum, a URL, a `translatable: false` field is never offered, whatever its
+ * name. A block whose key declares no shape (`{}`, or no declaration) keeps the heuristic above.
+ *
+ * ⛔ Until 2026-10-02 every block was walked by the heuristic, so a field the heuristic does not know
+ * — a `style: display-black` naming one of a component's looks — was offered for translation, and
+ * a translated one quietly fell back to the component's default look.
+ *
+ * One rule for the four places that walk a block — extraction, the build's merge, the push and the
+ * pull — so a string extracted is a string translated, and a translation pushed is one read back.
+ *
+ * @param {object|Array} data - the block's value: a list of items, or one
+ * @param {(value: string, path: string) => string|void} visit
+ * @param {object|null} [model] - the block's lowered model (`data-models.js`), or null
+ */
+export function visitDataBlockStrings(data, visit, model = null) {
+  if (!model) return visitDataStrings(data, visit)
+  if (Array.isArray(data)) data.forEach((item, i) => visitModelStrings(item, model, visit, `[${i}]`))
+  else visitModelStrings(data, model, visit)
+}

package/src/i18n/extract.js

@@ -7,7 +7,7 @@
 
 import { resolveDefaultLocale } from '@uniweb/core'
 import { computeHash, stripInlineTags } from './hash.js'
-import { visitDataStrings } from './data-strings.js'
+import { visitDataBlockStrings } from './data-strings.js'
 
 // ProseMirror inline fragment → inline markdown, for the TRANSLATOR-FACING half of
 // a unit. Same lazy-import-with-fallback pattern as merge.js, so the synchronous
@@ -25,9 +25,13 @@ try {
 /**
  * Extract all translatable units from site content
  * @param {Object} siteContent - Parsed site-content.json
+ * @param {Object} [options]
+ * @param {(type: string, tag: string) => Object|null} [options.dataModel] - what each section type
+ *   declares its data blocks are (`data-models.js::dataBlockModels`); without it, every block is
+ *   walked by the heuristic
  * @returns {Object} Manifest with translation units
  */
-export function extractTranslatableContent(siteContent) {
+export function extractTranslatableContent(siteContent, { dataModel = null } = {}) {
   const units = {}
 
   // The site's own Open Graph title and description (`site.yml` `seo:`), in the site's context.
@@ -41,7 +45,7 @@ export function extractTranslatableContent(siteContent) {
 
     // Extract section content
     for (const section of page.sections || []) {
-      extractFromSection(section, pageRoute, units)
+      extractFromSection(section, pageRoute, units, dataModel)
     }
   }
 
@@ -51,7 +55,7 @@ export function extractTranslatableContent(siteContent) {
     const pageRoute = notFoundPage.route || '/404'
     extractFromPageMeta(notFoundPage, pageRoute, units)
     for (const section of notFoundPage.sections || []) {
-      extractFromSection(section, pageRoute, units)
+      extractFromSection(section, pageRoute, units, dataModel)
     }
   }
 
@@ -64,7 +68,7 @@ export function extractTranslatableContent(siteContent) {
         if (layoutPage?.sections) {
           const pageRoute = layoutPage.route || `/layout/${layoutName === 'default' ? '' : layoutName + '/'}${areaKey}`
           for (const section of layoutPage.sections) {
-            extractFromSection(section, pageRoute, units)
+            extractFromSection(section, pageRoute, units, dataModel)
           }
         }
       }
@@ -169,7 +173,7 @@ export function translationContext(section, pageRoute) {
  * @param {string} pageRoute - Parent page route
  * @param {Object} units - Units accumulator
  */
-function extractFromSection(section, pageRoute, units) {
+function extractFromSection(section, pageRoute, units, dataModel = null) {
   const context = translationContext(section, pageRoute)
 
   // Extract from parsed semantic content if available
@@ -179,12 +183,12 @@ function extractFromSection(section, pageRoute, units) {
 
   if (section.content?.type === 'doc') {
     extractFromProseMirrorDoc(section.content, context, units)
-    extractFromDataBlocks(section.content, context, units)
+    extractFromDataBlocks(section.content, context, units, (tag) => dataModel?.(section.type, tag) ?? null)
   }
 
   // Recursively process subsections
   for (const subsection of section.subsections || []) {
-    extractFromSection(subsection, pageRoute, units)
+    extractFromSection(subsection, pageRoute, units, dataModel)
   }
 }
 
@@ -214,14 +218,14 @@ function extractFromSection(section, pageRoute, units) {
  * as the same per-string entries this lane writes — the block-element keying
  * contract is untouched.
  */
-function extractFromDataBlocks(doc, context, units) {
+function extractFromDataBlocks(doc, context, units, modelFor = () => null) {
   for (const node of dataBlockNodes(doc)) {
     const { tag, data } = node.attrs || {}
     if (!tag || !data || typeof data !== 'object') continue
 
-    visitDataStrings(data, (value, fieldPath) => {
+    visitDataBlockStrings(data, (value, fieldPath) => {
       addUnit(units, value, `data.${tag}.${fieldPath}`, context)
-    })
+    }, modelFor(tag))
   }
 }
 

package/src/i18n/index.js

@@ -14,6 +14,7 @@ import { join, dirname } from 'node:path'
 import { computeHash, normalizeText } from './hash.js'
 import { availableLocales, resolveLocaleList } from './locales.js'
 import { extractTranslatableContent } from './extract.js'
+import { dataBlockModels } from './data-models.js'
 import { syncManifests, formatSyncReport } from './sync.js'
 import { mergeTranslations, generateAllLocales } from './merge.js'
 import { auditLocale, cleanLocale, formatAuditReport } from './audit.js'
@@ -160,8 +161,8 @@ export async function extractManifest(siteRoot, siteContent, options = {}) {
     dryRun = false
   } = options
 
-  // Extract translatable content
-  const manifest = extractTranslatableContent(siteContent)
+  // Extract translatable content — a data block by what its section type declares it is
+  const manifest = extractTranslatableContent(siteContent, { dataModel: await dataBlockModels(siteRoot) })
 
   // Ensure locales directory exists
   const localesPath = join(siteRoot, localesDir)
@@ -372,6 +373,8 @@ export async function buildLocalizedContent(siteRoot, options = {}) {
   const defaultLocale = resolveDefaultLocale(siteContent.config)
 
   const outputs = {}
+  // What each section type declares its data blocks are, so a block translates what extraction offered.
+  const dataModel = await dataBlockModels(siteRoot)
 
   // ⭐ The DEFAULT locale's payload needs the same stamp. It is not written in
   // this loop — it is the source this function reads — but a visitor landing on
@@ -420,7 +423,8 @@ export async function buildLocalizedContent(siteRoot, options = {}) {
         fallbackToSource,
         locale,
         localesDir: localesPath,
-        freeformEnabled: true
+        freeformEnabled: true,
+        dataModel
       })
 
       // Check for stale/orphaned free-form translations and warn
@@ -428,7 +432,8 @@ export async function buildLocalizedContent(siteRoot, options = {}) {
     } else {
       // Use sync merge (original behavior)
       translated = mergeTranslations(siteContent, translations, {
-        fallbackToSource
+        fallbackToSource,
+        dataModel
       })
     }