@uniweb/build 0.75.0 → 0.76.0

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/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/uwx/data-schema.js

@@ -451,8 +451,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
 }
 

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/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) {