@uniweb/build 0.74.4 → 0.75.1

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/plugin.js

@@ -251,6 +251,7 @@ async function processDevSectionFetches(sections, fetchOptions, resolve) {
 }
 import { generateSearchIndex, getSearchIndexFilename } from '@uniweb/projections'
 import { mergeTranslations } from '../i18n/merge.js'
+import { dataBlockModels, NO_DATA_MODELS } from '../i18n/data-models.js'
 import { searchDeclaredOn } from './search-declared.js'
 import { mountDevApi } from '../dev/api-mount.js'
 
@@ -654,6 +655,9 @@ export function siteContentPlugin(options = {}) {
   }
 
   let siteContent = null
+  // What each section type declares its data blocks are — read once per collection of the site.
+  let dataModelPromise = null
+  const dataModels = () => (dataModelPromise ||= dataBlockModels(resolvedSitePath).catch(() => NO_DATA_MODELS))
   let resolvedSitePath = null
   let resolvedPublicDir = null
   let resolvedOutDir = null
@@ -791,7 +795,8 @@ export function siteContentPlugin(options = {}) {
     return mergeTranslations(siteContent, translations || {}, {
       locale,
       localesDir: join(resolvedSitePath, localesDir),
-      freeformEnabled: hasFreeform
+      freeformEnabled: hasFreeform,
+      dataModel: await dataModels()
     })
   }
 
@@ -951,6 +956,7 @@ export function siteContentPlugin(options = {}) {
         // strict on a production build: a mount that contributes no pages is a
         // warning while you author and a broken deploy once you ship.
         siteContent = await collectForBundle(resolvedSitePath, { foundationPath, dropUnpublished: isProduction, base: basePath, strict: isProduction })
+        dataModelPromise = null
         headHtml = await loadHeadHtml()
         console.log(`[site-content] Collected ${siteContent.pages?.length || 0} pages`)
 
@@ -1020,6 +1026,7 @@ export function siteContentPlugin(options = {}) {
             console.log('[site-content] Content changed, rebuilding...')
             try {
               siteContent = await collectForBundle(resolvedSitePath, { foundationPath, base: basePath })
+              dataModelPromise = null
               headHtml = await loadHeadHtml()
               if (materialize) {
                 queriesConfig = siteContent.config?.queries

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/index.js

@@ -78,6 +78,8 @@ export { matchStoredRecords } from './record-identity.js'
 // The scope a site's `@/x` refs resolve into — its foundation's. A pull resolves it
 // up front and hands it to the synchronous projections above.
 export { siteSelfScope } from './self-scope.js'
+// What each section type declares its data blocks are — a pull reads a translated block back by it.
+export { dataBlockModels } from '../i18n/data-models.js'
 export {
   siteInfoToConfig,
   sectionRecordToFile,

package/src/uwx/locale-sync.js

@@ -23,7 +23,7 @@ import { YAML_OPTIONS } from '../utils/yaml-schema.js'
 import { proseMirrorToMarkdown, serializeInlineContent } from '@uniweb/content-writer'
 import { computeHash } from '../i18n/hash.js'
 import { blockElements, elementText, dataBlockNodes } from '../i18n/extract.js'
-import { visitDataStrings } from '../i18n/data-strings.js'
+import { visitDataBlockStrings } from '../i18n/data-strings.js'
 import { resolveDocForLocale } from '../i18n/merge.js'
 import { computeSourceHash } from '../i18n/freeform-manifest.js'
 import { sameMarkdownDocument, canonicalJson } from './same-content.js'
@@ -167,8 +167,11 @@ export function loadLocaleTranslations(siteRoot, locales, subdir = '') {
  * @param {string} sourceLocale
  * @param {string[]} [targetLocales]
  * @param {object} [translations] - `{ locale: { hash: tgt } }` from loadLocaleTranslations
+ * @param {object} [context] - the section's translation context
+ * @param {(tag: string) => object|null} [modelFor] - the section's data-block models by tag
+ *   (`i18n/data-models.js`), so a block is translated as the build translates it
  */
-export function localizeContentDoc(doc, sourceLocale, targetLocales, translations, context = undefined) {
+export function localizeContentDoc(doc, sourceLocale, targetLocales, translations, context = undefined, modelFor = () => null) {
   // Non-docs (null, an already-localized map) pass through untouched.
   if (!isProseMirrorDoc(doc)) return doc
 
@@ -178,7 +181,7 @@ export function localizeContentDoc(doc, sourceLocale, targetLocales, translation
       const table = translations[locale]
       if (!table) continue
       // With the section's context, so a context-specific override resolves as the build resolves it.
-      const resolved = resolveDocForLocale(doc, table, context)
+      const resolved = resolveDocForLocale(doc, table, context, modelFor)
       if (resolved) result[locale] = resolved
     }
   }
@@ -363,7 +366,7 @@ export function createTranslationCollector(sourceLocale, { siteRoot = null } = {
  * per-locale link hrefs survive. Keyed by the source element's cleaned text, so
  * `computeHash(key)` matches the extractor's unit hash — closing the round trip.
  */
-function deriveStructuralMap(sourceDoc, targetDoc) {
+function deriveStructuralMap(sourceDoc, targetDoc, modelFor = () => null) {
   if (!isProseMirrorDoc(sourceDoc) || !isProseMirrorDoc(targetDoc)) return null
   const src = blockElements(sourceDoc)
   const tgt = blockElements(targetDoc)
@@ -383,15 +386,18 @@ function deriveStructuralMap(sourceDoc, targetDoc) {
     // a mark we can't serialize → don't risk a lossy map; store as free-form
     return null
   }
-  return addDataBlockStrings(map, sourceDoc, targetDoc)
+  return addDataBlockStrings(map, sourceDoc, targetDoc, modelFor)
 }
 
 // ⭐ A TAGGED DATA BLOCK's translated strings, read pairwise — the strings the build translates
-// (`visitDataStrings`, the extractor's judgement), keyed by their source text as the build keys them.
+// (`visitDataBlockStrings`: a block's declared shape, else the extractor's heuristic), keyed by their
+// source text as the build keys them. ⭐ Walked by the same model the push translated with — the pairing
+// is by position, so a declared text field the heuristic skips (a `status`) would otherwise read a
+// faithful translation as another shape.
 // A target that is not the source with only those strings changed — another shape, another `href` —
 // cannot be said per string, and the whole translation is free-form. ⛔ Until 2026-09-26 a data block
 // was not read here at all, and its translations were not sent (`merge.js::translateDataBlocks`).
-function addDataBlockStrings(map, sourceDoc, targetDoc) {
+function addDataBlockStrings(map, sourceDoc, targetDoc, modelFor = () => null) {
   const srcBlocks = dataBlockNodes(sourceDoc)
   const tgtBlocks = dataBlockNodes(targetDoc)
   if (srcBlocks.length !== tgtBlocks.length) return null
@@ -405,7 +411,7 @@ function addDataBlockStrings(map, sourceDoc, targetDoc) {
     }
     const strings = (data) => {
       const out = []
-      visitDataStrings(JSON.parse(JSON.stringify(data ?? null)), (value) => void out.push(value))
+      visitDataBlockStrings(JSON.parse(JSON.stringify(data ?? null)), (value) => void out.push(value), modelFor(s.tag))
       return out
     }
     const from = strings(s.data)
@@ -418,7 +424,7 @@ function addDataBlockStrings(map, sourceDoc, targetDoc) {
       pairs.set(from[j], to[j])
     }
     const rebuilt = JSON.parse(JSON.stringify(s.data))
-    visitDataStrings(rebuilt, (value) => pairs.get(value) ?? value)
+    visitDataBlockStrings(rebuilt, (value) => pairs.get(value) ?? value, modelFor(s.tag))
     if (canonicalJson(rebuilt) !== canonicalJson(t.data)) return null
     for (const [from, to] of pairs) map[from.trim()] = to
   }
@@ -436,7 +442,7 @@ function addDataBlockStrings(map, sourceDoc, targetDoc) {
  * reserved `@` (and `$`-prefixed) key is opaque metadata — NEVER a locale. A bare
  * doc (no locale wrap) is returned unchanged.
  */
-export function unwrapLocalizedContent(content, sourceLocale, collector, freeformRelPath, freeformCandidates = null, context = null) {
+export function unwrapLocalizedContent(content, sourceLocale, collector, freeformRelPath, freeformCandidates = null, context = null, modelFor = () => null) {
   if (!isLocalizedContent(content)) return content
   const source = content[sourceLocale]
   for (const [locale, value] of Object.entries(content)) {
@@ -445,7 +451,7 @@ export function unwrapLocalizedContent(content, sourceLocale, collector, freefor
     if (isProseMirrorDoc(value)) {
       // A translation the site keeps as a free-form file stays one, even when it lines up.
       const kept = collector?.keptFreeform?.(locale, freeformCandidates || freeformRelPath) || null
-      const map = kept ? null : deriveStructuralMap(source, value)
+      const map = kept ? null : deriveStructuralMap(source, value, modelFor)
       if (map) collector?.addStructuralMap?.(locale, map, context)
       else collector?.noteFreeform?.(locale, value, source, kept || freeformRelPath)
     } else {

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.

package/src/uwx/site-project.js

@@ -403,7 +403,7 @@ export function siteInfoToConfig({ document, siteRoot, backend = null, sourceLoc
  *        structural maps on a localized `content` field are captured into it
  * @returns {'updated'|'unchanged'}
  */
-export function sectionRecordToFile({ filePath, record, sourceLocale = LOCALIZED_FIELD_ASSUMPTION.defaultSourceLocale, collector, freeformRelPath, freeformCandidates = null, writeId = true, context = null }) {
+export function sectionRecordToFile({ filePath, record, sourceLocale = LOCALIZED_FIELD_ASSUMPTION.defaultSourceLocale, collector, freeformRelPath, freeformCandidates = null, writeId = true, context = null, dataModel = null }) {
   // ⛔ A stored `preset` or `input` is not written back: neither has an effect, and the build
   // would only warn about it (2026-09-27).
   // ⛔ No `background` / `theme_override` / `insets` / `fetch`: the site-content Model dropped all
@@ -416,7 +416,8 @@ export function sectionRecordToFile({ filePath, record, sourceLocale = LOCALIZED
   // target-locale structural maps are captured into the locales/ collector, and any
   // free-form target body is captured with `freeformRelPath` for writing under
   // locales/freeform/. A bare doc (source-only / pre-localization) passes through.
-  const sourceContent = unwrapLocalizedContent(content, sourceLocale, collector, freeformRelPath, freeformCandidates, context)
+  // A data block is read back by what the section's type declares it is, as the push translated it.
+  const sourceContent = unwrapLocalizedContent(content, sourceLocale, collector, freeformRelPath, freeformCandidates, context, (tag) => dataModel?.(type, tag) ?? null)
 
   const { hidden: paramHidden, fetch: paramFetch, ...paramsRest } = params && typeof params === 'object' ? params : {}
   const frontmatter = {}
@@ -556,6 +557,7 @@ export function pageSectionsToFiles({ pageDir, pageSections, ctx, pageContext })
         record,
         sourceLocale: ctx?.sourceLocale,
         collector: ctx?.collector,
+        dataModel: ctx?.dataModel,
         freeformRelPath,
         freeformCandidates,
         writeId: fileSectionName(filePath) !== stableId,
@@ -1081,6 +1083,7 @@ function projectLayout(layoutSections, layoutBaseDir, report, prune, ctx) {
       record,
       sourceLocale: ctx?.sourceLocale,
       collector: ctx?.collector,
+      dataModel: ctx?.dataModel,
       writeId: fileSectionName(filePath) !== stableId,
       freeformRelPath: stableId ? buildFreeformPath({ stableId }, page) : null,
       freeformCandidates: stableId ? freeformPathsFor({ stableId }, page) : null,
@@ -1116,7 +1119,7 @@ function projectLayout(layoutSections, layoutBaseDir, report, prune, ctx) {
  *        `declarationsToQueriesYml`, whose default it overrides.
  * @returns {{ config: object, collections: object, locales: object, pages: string[], sections: string[], layout: string[], deleted: string[], renamed: object[] }}
  */
-export function siteContentDocumentToProject({ document, siteRoot, backend = null, sourceLocale = LOCALIZED_FIELD_ASSUMPTION.defaultSourceLocale, prune = false, keepAuthoredFoundation = false, scope }) {
+export function siteContentDocumentToProject({ document, siteRoot, backend = null, sourceLocale = LOCALIZED_FIELD_ASSUMPTION.defaultSourceLocale, prune = false, keepAuthoredFoundation = false, scope, dataModel = null }) {
   const report = { config: null, collections: null, locales: null, assets: null, pages: [], sections: [], layout: [], deleted: [], renamed: [] }
 
   // Collects target-locale translations of localized scalars as they're projected;
@@ -1145,7 +1148,7 @@ export function siteContentDocumentToProject({ document, siteRoot, backend = nul
   // rename detection, build a fresh one as we project, then persist it. Items not
   // re-projected (deleted) drop out naturally. `collector` rides along to capture
   // localized scalars during the page walk.
-  const ctx = { siteRoot, oldIndex: readPullIndex(siteRoot), newIndex: {}, report, collector, sourceLocale, sectionFiles: new Map() }
+  const ctx = { siteRoot, oldIndex: readPullIndex(siteRoot), newIndex: {}, report, collector, sourceLocale, sectionFiles: new Map(), dataModel }
   // Where the site keeps its localized URLs — `site.yml`'s map, when it has one (`pageSlugToYml`).
   const siteMap = readAuthoredYaml(join(siteRoot, 'site.yml'))?.i18n?.routeTranslations
   ctx.routes = { siteMap: isPlainRecord(siteMap) && Object.keys(siteMap).length ? siteMap : null, slugs: new Map() }

package/src/uwx/site.js

@@ -45,6 +45,7 @@
 // (favicon/assets — carried out of band).
 
 import { readdir, readFile } from 'node:fs/promises'
+import { dataBlockModels } from '../i18n/data-models.js'
 import { existsSync } from 'node:fs'
 import { join, parse, relative } from 'node:path'
 import {
@@ -245,6 +246,8 @@ export function buildRouteOf(record, parentRoute, sourceLocale) {
 // hits the filesystem.
 async function localizeContentTree(pages, layoutSections, sourceLocale, targetLocales, translations, siteRoot) {
   const freeformBase = localesDir(siteRoot)
+  // What each section type declares its data blocks are, so a block is pushed as the build translates it.
+  const dataModel = await dataBlockModels(siteRoot)
 
   const localizeSection = async (record, page) => {
     if (!record.content) return
@@ -252,7 +255,7 @@ async function localizeContentTree(pages, layoutSections, sourceLocale, targetLo
     // Resolved in the section's context, as the build resolves it (`translationContext`): a
     // context-specific override applies here and nowhere else. ⛔ Until 2026-09-26 every section was
     // resolved with none, so an override never reached a backend.
-    let localized = localizeContentDoc(record.content, sourceLocale, targetLocales, translations, translationContext({ stableId }, page?.route))
+    let localized = localizeContentDoc(record.content, sourceLocale, targetLocales, translations, translationContext({ stableId }, page?.route), (tag) => dataModel(record.type, tag))
     if (page) {
       const section = { stableId }
       for (const locale of targetLocales) {