@uniweb/build 0.15.13 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.15.13",
+  "version": "0.16.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -59,14 +59,15 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
-    "@uniweb/projections": "0.1.5",
-    "@uniweb/content-writer": "0.2.9",
-    "@uniweb/theming": "0.1.14"
+    "@uniweb/theming": "0.1.15",
+    "@uniweb/projections": "0.2.0",
+    "@uniweb/content-writer": "0.3.0"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "0.8.41",
-    "@uniweb/content-reader": "1.1.18",
-    "@uniweb/schemas": "0.2.4"
+    "@uniweb/runtime": "0.9.0",
+    "@uniweb/schemas": "0.2.4",
+    "@uniweb/content-reader": "1.2.0",
+    "@uniweb/semantic-parser": "1.2.0"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -75,7 +76,7 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "0.7.33"
+    "@uniweb/core": "0.8.0"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/i18n/collections.js

@@ -14,51 +14,23 @@ import { readFile, writeFile, readdir, mkdir } from 'fs/promises'
 import { existsSync } from 'fs'
 import { join } from 'path'
 import { pathToFileURL } from 'url'
+import { DATA_DIR } from '@uniweb/core'
 import { computeHash } from './hash.js'
 import { loadFreeformCollectionItem } from './freeform.js'
+// The heuristic judgement about which strings inside structured data are prose.
+// It lives in its own module because the page lane needs exactly the same
+// answer for a tagged data block's payload — a `label` is prose and an `href`
+// is not, wherever the value came from. Moved rather than copied: two tuned
+// denylists would drift, and drift here is silent.
+import {
+  NON_TRANSLATABLE_TYPES,
+  HEURISTIC_SKIP_FIELDS,
+  MAX_HEURISTIC_DEPTH,
+  isStructuralString,
+} from './data-strings.js'
 
 export const COLLECTIONS_DIR = 'collections'
 
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-/** Types that are never translatable regardless of schema */
-const NON_TRANSLATABLE_TYPES = new Set([
-  'number', 'boolean', 'date', 'datetime', 'url', 'email', 'image'
-])
-
-/** Field names skipped by the heuristic extractor (structural, not human-readable) */
-const HEURISTIC_SKIP_FIELDS = new Set([
-  'slug', 'id', 'type', 'status', 'href', 'url', 'src', 'icon',
-  'target', 'email', 'phone', 'orcid', 'doi', 'arxiv', 'isbn',
-  'pmid', 'bibtex', 'pdf', 'code', 'data', 'slides', 'video',
-  'repository', 'caseStudy', 'website', 'avatar', 'image',
-  'thumbnail', 'currency', 'order', 'hidden', 'current',
-  'featured', 'published', 'allDay', 'remote', 'hybrid',
-  'noindex', 'corresponding', 'required', 'virtual',
-  'lastModified', 'date', 'updated', 'posted', 'submitted',
-  'accepted', 'startDate', 'endDate', 'deadline',
-  'readTime', 'citations', 'capacity', 'volume', 'issue', 'pages',
-  'time', 'timezone',
-])
-
-/** String patterns that indicate non-translatable values */
-const HEURISTIC_SKIP_PATTERNS = [
-  /^https?:\/\//,                  // URLs
-  /^mailto:/,                      // mailto links
-  /^[^\s@]+@[^\s@]+\.[^\s@]+$/,   // email addresses
-  /^\d{4}-\d{2}-\d{2}/,           // ISO dates
-  /^#[0-9a-fA-F]{3,8}$/,          // hex colors
-  /^[\w./\\-]+\.\w{2,4}$/,        // file paths (e.g., ./logo.svg, /img/hero.jpg)
-  /^[A-Z]{3}$/,                   // currency codes (USD, EUR)
-  /^\d+(\.\d+)?$/,                // plain numbers as strings
-  /^\d{1,2}:\d{2}(:\d{2})?$/,    // times (09:00, 14:30:00)
-]
-
-/** Max recursion depth for heuristic extraction */
-const MAX_HEURISTIC_DEPTH = 5
-
 // ---------------------------------------------------------------------------
 // Schema resolution
 // ---------------------------------------------------------------------------
@@ -85,8 +57,14 @@ async function resolveSchema(collectionName, siteRoot) {
 
   let schema = null
 
-  // 1. Companion schema file
-  const companionPath = join(siteRoot, 'public', 'data', `${collectionName}.schema.js`)
+  // 1. Companion schema file, beside the collection it describes.
+  //
+  // This used to be looked up in `public/<DATA_DIR>/` — next to the compiled
+  // output rather than the source. That directory is the build's, and asking
+  // an author to write into it was the one remaining place the framework
+  // contradicted its own rule that `collections/` is the only way to provide
+  // structured data. The schema describes the source, so it lives with it.
+  const companionPath = join(siteRoot, 'collections', `${collectionName}.schema.js`)
   if (existsSync(companionPath)) {
     try {
       const mod = await import(pathToFileURL(companionPath).href)
@@ -290,13 +268,6 @@ function extractFromItemHeuristic(data, pathPrefix, context, units, depth) {
   }
 }
 
-/**
- * Check if a string value looks structural (not human-readable).
- */
-function isStructuralString(value) {
-  return HEURISTIC_SKIP_PATTERNS.some(pattern => pattern.test(value))
-}
-
 // ---------------------------------------------------------------------------
 // Schema-guided translation
 // ---------------------------------------------------------------------------
@@ -412,7 +383,7 @@ function translateItemHeuristic(data, context, translations, depth) {
  * @returns {Promise<Object>} Manifest with translation units
  */
 export async function extractCollectionContent(siteRoot, options = {}) {
-  const dataDir = join(siteRoot, 'public', 'data')
+  const dataDir = join(siteRoot, 'public', DATA_DIR)
 
   if (!existsSync(dataDir)) {
     return { version: '1.0', units: {} }
@@ -577,7 +548,7 @@ export async function buildLocalizedCollections(siteRoot, options = {}) {
     freeformEnabled = true
   } = options
 
-  const dataDir = join(siteRoot, 'public', 'data')
+  const dataDir = join(siteRoot, 'public', DATA_DIR)
 
   if (!existsSync(dataDir)) {
     return {}
@@ -615,7 +586,7 @@ export async function buildLocalizedCollections(siteRoot, options = {}) {
     const hasFreeform = freeformEnabled && existsSync(freeformDir)
 
     // Create locale data directory
-    const localeDataDir = join(outputDir, locale, 'data')
+    const localeDataDir = join(outputDir, locale, DATA_DIR)
     await mkdir(localeDataDir, { recursive: true })
 
     outputs[locale] = {}

package/src/i18n/data-strings.js

@@ -0,0 +1,114 @@
+/**
+ * Which strings inside STRUCTURED DATA are human-readable prose.
+ *
+ * A tagged data block (```yaml:nav, ```json:pricing) carries an arbitrary shape,
+ * so there is no element to key a translation unit to — only a tree of values,
+ * most of which are machinery. A nav's `label` is prose; its `href` and `icon`
+ * are not. Guessing wrong in one direction leaves a site half-translated; in the
+ * other it rewrites a URL into another language and breaks the link.
+ *
+ * The judgement was already made and tuned for collections, which have exactly
+ * this problem. This module is that judgement, moved somewhere both lanes can
+ * reach rather than copied — the copy is how the two would drift, and the whole
+ * point is that a `label` means the same thing in a collection record and in a
+ * data block.
+ *
+ * An ALLOWLIST of shapes is impossible here (the data is author-defined), so
+ * this is necessarily a denylist, and it is deliberately conservative: a missed
+ * skip shows up as a translatable string an author can leave alone, while a
+ * missed field shows up as untranslated content nobody notices.
+ */
+
+/** Types that are never translatable regardless of schema. */
+export const NON_TRANSLATABLE_TYPES = new Set([
+  'number', 'boolean', 'date', 'datetime', 'url', 'email', 'image'
+])
+
+/** Field names skipped by the heuristic extractor (structural, not human-readable). */
+export const HEURISTIC_SKIP_FIELDS = new Set([
+  'slug', 'id', 'type', 'status', 'href', 'url', 'src', 'icon',
+  'target', 'email', 'phone', 'orcid', 'doi', 'arxiv', 'isbn',
+  'pmid', 'bibtex', 'pdf', 'code', 'data', 'slides', 'video',
+  'repository', 'caseStudy', 'website', 'avatar', 'image',
+  'thumbnail', 'currency', 'order', 'hidden', 'current',
+  'featured', 'published', 'allDay', 'remote', 'hybrid',
+  'noindex', 'corresponding', 'required', 'virtual',
+  'lastModified', 'date', 'updated', 'posted', 'submitted',
+  'accepted', 'startDate', 'endDate', 'deadline',
+  'readTime', 'citations', 'capacity', 'volume', 'issue', 'pages',
+  'time', 'timezone',
+])
+
+/** String patterns that indicate non-translatable values. */
+export const HEURISTIC_SKIP_PATTERNS = [
+  /^https?:\/\//,                  // URLs
+  /^mailto:/,                      // mailto links
+  /^[^\s@]+@[^\s@]+\.[^\s@]+$/,   // email addresses
+  /^\d{4}-\d{2}-\d{2}/,           // ISO dates
+  /^#[0-9a-fA-F]{3,8}$/,          // hex colors
+  /^[\w./\\-]+\.\w{2,4}$/,        // file paths (e.g., ./logo.svg, /img/hero.jpg)
+  /^[A-Z]{3}$/,                   // currency codes (USD, EUR)
+  /^\d+(\.\d+)?$/,                // plain numbers as strings
+  /^\d{1,2}:\d{2}(:\d{2})?$/,    // times (09:00, 14:30:00)
+]
+
+/** Max recursion depth for heuristic extraction. */
+export const MAX_HEURISTIC_DEPTH = 5
+
+/** Whether a string value looks structural rather than human-readable. */
+export function isStructuralString(value) {
+  return HEURISTIC_SKIP_PATTERNS.some((pattern) => pattern.test(value))
+}
+
+/**
+ * Walk structured data and hand every translatable-looking STRING to `visit`.
+ *
+ * One walker for both directions, the same discipline the document walk uses:
+ * extraction returns nothing and collects, application returns a replacement and
+ * the walker writes it back. Two copies of a rule this fiddly is how the
+ * extracted set and the applied set end up different, which fails as content
+ * that appears in the manifest, gets translated by a human, and still renders in
+ * the source language.
+ *
+ * Mutates `data` in place when `visit` returns a different string, so callers
+ * that must not mutate should pass a clone.
+ *
+ * @param {*} data - any parsed YAML/JSON value
+ * @param {(value: string, path: string) => string|void} visit
+ * @param {string} [path] - dotted path, for the unit's `field` metadata
+ * @param {number} [depth]
+ */
+export function visitDataStrings(data, visit, path = '', depth = 0) {
+  if (!data || typeof data !== 'object' || depth > MAX_HEURISTIC_DEPTH) return
+
+  const isArray = Array.isArray(data)
+  const keys = isArray ? data.map((_, i) => i) : Object.keys(data)
+
+  for (const key of keys) {
+    const value = data[key]
+    if (value === undefined || value === null) continue
+
+    const fieldPath = isArray
+      ? `${path}[${key}]`
+      : path
+        ? `${path}.${key}`
+        : String(key)
+
+    if (typeof value === 'string') {
+      // A skip-list entry applies to a NAMED field. Inside an array the key is
+      // an index and carries no meaning, so only the value patterns apply —
+      // otherwise a list of prose strings would be skipped by position.
+      if (!isArray && HEURISTIC_SKIP_FIELDS.has(key)) continue
+      if (isStructuralString(value)) continue
+      if (!value.trim()) continue
+
+      const replacement = visit(value, fieldPath)
+      if (typeof replacement === 'string' && replacement !== value) {
+        data[key] = replacement
+      }
+    } else if (typeof value === 'object') {
+      visitDataStrings(value, visit, fieldPath, depth + 1)
+    }
+    // numbers and booleans are never prose
+  }
+}

package/src/i18n/extract.js

@@ -7,6 +7,7 @@
 
 import { resolveDefaultLocale } from '@uniweb/core'
 import { computeHash, stripInlineTags } from './hash.js'
+import { visitDataStrings } from './data-strings.js'
 
 /**
  * Extract all translatable units from site content
@@ -130,6 +131,7 @@ function extractFromSection(section, pageRoute, units) {
 
   if (section.content?.type === 'doc') {
     extractFromProseMirrorDoc(section.content, context, units)
+    extractFromDataBlocks(section.content, context, units)
   }
 
   // Recursively process subsections
@@ -138,6 +140,61 @@ function extractFromSection(section, pageRoute, units) {
   }
 }
 
+/**
+ * Extract the human-readable strings inside a section's TAGGED DATA BLOCKS.
+ *
+ * A ```yaml:nav block's link labels, a ```yaml:pricing block's plan names — the
+ * strings an author most expects to see translated, and which stayed in the
+ * source language on every multilingual site until 2026-07-30 because nothing
+ * in this file mentioned `dataBlock`.
+ *
+ * Which strings count is not this file's judgement to make: it is the same
+ * question collections answer for a record's fields, so the same detection runs
+ * here (`data-strings.js`).
+ *
+ * DELIBERATELY SEPARATE from `extractFromProseMirrorDoc`, and not folded into
+ * it. That function is also `extractUnitsFromDoc`, which publishes the
+ * structural-keying contract pinned by tests/i18n/structural-keying-vectors.json
+ * — units keyed by a BLOCK ELEMENT's text. A data string is not a block
+ * element's text and has no place in that map. The consequence is real rather
+ * than tidy: `deriveStructuralMap` recovers a pulled translation by walking
+ * block elements, so a data string translated on the sync wire would be
+ * invisible to it — neither captured in the map nor counted as divergence — and
+ * would be silently lost on the next pull. So this lane is the BUILD lane only
+ * (the manifest, and `dist/{locale}/`), which is where the reported bug lives.
+ * Carrying data-block translations across the sync wire needs a representation
+ * that contract does not have yet.
+ */
+function extractFromDataBlocks(doc, context, units) {
+  for (const node of dataBlockNodes(doc)) {
+    const { tag, data } = node.attrs || {}
+    if (!tag || !data || typeof data !== 'object') continue
+
+    visitDataStrings(data, (value, fieldPath) => {
+      addUnit(units, value, `data.${tag}.${fieldPath}`, context)
+    })
+  }
+}
+
+/**
+ * Every tagged data block in a doc, including any nested inside a container.
+ */
+function dataBlockNodes(doc) {
+  const out = []
+  const walk = (nodes) => {
+    for (const node of nodes || []) {
+      if (!node) continue
+      if (node.type === 'dataBlock') out.push(node)
+      else if (CONTAINER_BLOCKS.has(node.type)) walk(node.content)
+      else if (node.type === 'bulletList' || node.type === 'orderedList') {
+        for (const listItem of node.content || []) walk(listItem.content)
+      }
+    }
+  }
+  walk(doc?.content)
+  return out
+}
+
 /**
  * Extract translatable strings from ProseMirror document
  * @param {Object} doc - ProseMirror document
@@ -165,28 +222,103 @@ function extractFromProseMirrorDoc(doc, context, units) {
   let headingIndex = { h1: 0, h2: 0, h3: 0, h4: 0 }
   let paragraphIndex = 0
 
-  for (const node of doc.content) {
+  visitTranslatableBlocks(doc.content, (node, listIndex) => {
     if (node.type === 'heading') {
       const text = elementText(node)
-      if (!text) continue
+      if (!text) return
 
       const level = node.attrs?.level || 1
       const field = getHeadingField(level, headingIndex)
       headingIndex[`h${level}`]++
 
       addUnit(units, text, field, context)
-    } else if (node.type === 'paragraph') {
-      // Whole-element keying: ONE unit per paragraph, with link text kept INLINE
-      // (not split into a separate link.label unit). The conformance gate is
-      // tests/i18n/structural-keying-vectors.json (vectors A–H).
-      const text = elementText(node)
-      if (text) {
-        const field = paragraphIndex === 0 ? 'paragraph' : `paragraph.${paragraphIndex}`
-        addUnit(units, text, field, context)
-        paragraphIndex++
-      }
+      return
+    }
+
+    // Whole-element keying: ONE unit per paragraph, with link text kept INLINE
+    // (not split into a separate link.label unit). The conformance gate is
+    // tests/i18n/structural-keying-vectors.json.
+    const text = elementText(node)
+    if (!text) return
+
+    if (listIndex !== null) {
+      addUnit(units, text, `list.${listIndex}`, context)
+      return
+    }
+
+    const field = paragraphIndex === 0 ? 'paragraph' : `paragraph.${paragraphIndex}`
+    addUnit(units, text, field, context)
+    paragraphIndex++
+  })
+}
+
+/**
+ * Block node types whose children carry translatable prose, so the walk has to
+ * descend into them.
+ *
+ * WHY THIS EXISTS. The walk used to handle four node types and recurse into
+ * nothing, so a string inside ANY container was invisible to translation: a
+ * callout's body, a table cell, a blockquote. On a multilingual site those
+ * silently stayed in the source language, and nothing reported it. That
+ * predates concept blocks — adding one more prose container without fixing the
+ * walk would have inherited the hole in the place it hurts most, since a
+ * concept block is prose, which is the thing translation exists for.
+ *
+ * An explicit set rather than "recurse into anything with content", because the
+ * denylist version is the dangerous one: `codeBlock` also has content, and
+ * extracting source code as translatable prose would be worse than missing it.
+ *
+ * KEEP IN SYNC with the editor's own container list. It maintains a second
+ * implementation of this walk over the same documents and already recursed
+ * containers when this one did not, so the two disagreed — the shared vectors
+ * in tests/i18n/structural-keying-vectors.json are the only thing pinning them
+ * together, and they are kept in step by hand.
+ */
+export const CONTAINER_BLOCKS = new Set([
+  'concept_block', // ```md:<tag> — a concept's body is authored prose
+  'inset_block', // ```@Component{params} — a callout's body is authored prose
+  'blockquote',
+  'table',
+  'tableRow',
+  'tableCell',
+])
+
+/**
+ * Walk a content array and hand every translatable BLOCK element to `visit`, in
+ * document order, descending into containers.
+ *
+ * ONE walker with two consumers, deliberately. Extraction (into the manifest)
+ * and resolution (applying a translation) used to be two separate walks over
+ * the same four node types. Two copies of one rule is the shape that fails
+ * halfway: teach only the extractor about a container and its strings reach the
+ * manifest but are never applied; teach only the resolver and there is nothing
+ * to apply. Neither half fails loudly. They cannot drift now because there is
+ * only one of them.
+ *
+ * @param {Array} nodes - a content array
+ * @param {(node: Object, listIndex: number|null) => void} visit
+ */
+function visitTranslatableBlocks(nodes, visit) {
+  for (const node of nodes || []) {
+    if (!node) continue
+
+    if (node.type === 'heading' || node.type === 'paragraph') {
+      visit(node, null)
     } else if (node.type === 'bulletList' || node.type === 'orderedList') {
-      extractFromList(node, context, units)
+      // A list item's index is part of its unit's field name, so lists keep
+      // their own branch rather than folding into the container recursion.
+      ;(node.content || []).forEach((listItem, index) => {
+        if (listItem.type !== 'listItem') return
+        for (const child of listItem.content || []) {
+          if (child.type === 'paragraph') {
+            visit(child, index)
+          } else if (CONTAINER_BLOCKS.has(child.type)) {
+            visitTranslatableBlocks([child], visit)
+          }
+        }
+      })
+    } else if (CONTAINER_BLOCKS.has(node.type)) {
+      visitTranslatableBlocks(node.content, visit)
     }
   }
 }
@@ -203,27 +335,6 @@ function getHeadingField(level, index) {
   return `heading.h${level}.${index[`h${level}`]}`
 }
 
-/**
- * Extract from list items — one whole-element unit per list item (link text
- * stays inline, same rule as paragraphs; vectors G and H).
- */
-function extractFromList(listNode, context, units) {
-  if (!listNode.content) return
-
-  listNode.content.forEach((listItem, index) => {
-    if (listItem.type === 'listItem' && listItem.content) {
-      for (const child of listItem.content) {
-        if (child.type === 'paragraph') {
-          const text = elementText(child)
-          if (text) {
-            addUnit(units, text, `list.${index}`, context)
-          }
-        }
-      }
-    }
-  })
-}
-
 /**
  * A block element's cleaned source text — the WHOLE-ELEMENT translation key.
  * ALL inline marks (bold, italic, link, span, …) flatten into the text: link
@@ -259,27 +370,14 @@ function collectInlineText(node) {
 
 /**
  * The translatable block elements of a content doc, in document order, with the
- * SAME coverage as extraction above (headings, paragraphs, and each list item's
- * paragraphs). Shared by the merge resolver (push) and the pull-side
- * structural-map derivation so all paths walk identically and keys never drift.
- * Returns the element nodes themselves — callers read `.type`/`.content` and key
- * them via elementText.
+ * SAME coverage as extraction above — because it is the same walk. Shared by the
+ * merge resolver (push) and the pull-side structural-map derivation so all paths
+ * walk identically and keys never drift. Returns the element nodes themselves —
+ * callers read `.type`/`.content` and key them via elementText.
  */
 export function blockElements(doc) {
   const out = []
-  for (const node of doc?.content || []) {
-    if (node.type === 'heading' || node.type === 'paragraph') {
-      out.push(node)
-    } else if (node.type === 'bulletList' || node.type === 'orderedList') {
-      for (const listItem of node.content || []) {
-        if (listItem.type === 'listItem' && listItem.content) {
-          for (const child of listItem.content) {
-            if (child.type === 'paragraph') out.push(child)
-          }
-        }
-      }
-    }
-  }
+  visitTranslatableBlocks(doc?.content, (node) => out.push(node))
   return out
 }
 

package/src/i18n/merge.js

@@ -15,6 +15,7 @@
 import { computeHash } from './hash.js'
 import { loadFreeformTranslation } from './freeform.js'
 import { elementText, blockElements } from './extract.js'
+import { visitDataStrings } from './data-strings.js'
 
 // Inline-markdown → ProseMirror inline fragment, for resolving a whole-element
 // translation VALUE (which carries marks/links/icons as inline markdown). Same
@@ -227,6 +228,7 @@ function translateSectionSync(section, pageRoute, translations, fallbackToSource
 
   if (section.content?.type === 'doc') {
     translateProseMirrorDoc(section.content, context, translations, fallbackToSource)
+    translateDataBlocks(section.content, context, translations, fallbackToSource)
   }
 
   // Recursively translate subsections
@@ -259,6 +261,7 @@ async function translateSectionAsync(section, page, translations, options) {
     // Fall back to hash-based translation
     if (section.content?.type === 'doc') {
       translateProseMirrorDoc(section.content, context, translations, fallbackToSource)
+      translateDataBlocks(section.content, context, translations, fallbackToSource)
     }
   }
 
@@ -302,6 +305,37 @@ function applyElementTranslation(node, context, translations, fallbackToSource)
   return false
 }
 
+/**
+ * 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
+ * applies is worse than no entry, because a translator has already done the work.
+ *
+ * Called from the two BUILD-lane section walks only, deliberately, and NOT from
+ * `resolveDocForLocale`. See `extractFromDataBlocks` for why: the sync wire's
+ * structural map is derived by walking block elements, so a translated data
+ * payload there would be neither captured nor flagged as divergent, and would be
+ * dropped on the next pull. Losing a translation silently is worse than not
+ * carrying one yet.
+ */
+function translateDataBlocks(doc, context, translations, fallbackToSource) {
+  const walk = (nodes) => {
+    for (const node of nodes || []) {
+      if (!node) continue
+      if (node.type === 'dataBlock') {
+        const data = node.attrs?.data
+        if (data && typeof data === 'object') {
+          visitDataStrings(data, (value) =>
+            lookupTranslation(value, context, translations, fallbackToSource)
+          )
+        }
+      } else if (Array.isArray(node.content)) {
+        walk(node.content)
+      }
+    }
+  }
+  walk(doc?.content)
+}
+
 /**
  * Resolve ONE ProseMirror content doc for a single target locale: a deep clone of
  * the source doc with each whole-element translated (inline content replaced from

package/src/index.js

@@ -18,6 +18,7 @@ export {
 export {
   validateItem,
   validateDataInputs,
+  validateConceptBlocks,
   isStaticallyCheckable,
 } from './validate-data.js'
 

package/src/prerender.js

@@ -11,7 +11,7 @@ import { readFile, writeFile, mkdir } from 'node:fs/promises'
 import { existsSync, readdirSync, statSync } from 'node:fs'
 import { join, dirname, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
-import { resolveDefaultLocale } from '@uniweb/core'
+import { resolveDefaultLocale, isDataUrl } from '@uniweb/core'
 import { executeFetch, mergeDataIntoContent } from './site/data-fetcher.js'
 import { shouldSplitContent } from './site/split-content.js'
 import { FONT_LINKS_MARKER } from './site/head-markers.js'
@@ -81,7 +81,7 @@ async function executeAllFetches(siteContent, siteDir, onProgress, localeInfo) {
     localeInfo.distDir
 
   function localizeFetch(config) {
-    if (!isNonDefaultLocale || !config.path?.startsWith('/data/')) return config
+    if (!isNonDefaultLocale || !isDataUrl(config.path)) return config
     return { ...config, path: `/${localeInfo.locale}${config.path}` }
   }
 
@@ -381,35 +381,19 @@ export function scopeFetchedData(fetchedData, scopeRoutes) {
 export function injectBuildData(html, siteContent, { splitContent = false, currentRoute = null, scopeRoutes = null } = {}) {
   let result = html
 
-  // Inject the theme's font <link> tags if not already present (the vite
-  // plugin normally puts them there when it builds index.html)
+  // Neither the theme <style> NOR the font <link>s are injected here anymore.
+  // Both are derived from the website graph (`website.themeData`), so they
+  // belong to the shared seam — @uniweb/runtime/ssr's injectPageContent(),
+  // which runs just before this — and every lane gets them from one
+  // implementation. The theme CSS sat here until 2026-07-28 and cloud-rendered
+  // pages were unstyled the whole time; the font links followed once
+  // FONT_LINKS_MARKER moved to @uniweb/theming, the one package both this and
+  // the runtime can read it from.
   //
-  // STILL HERE, and it is the remaining half of the 2026-07-28 seam fix.
-  // `theme.links` is graph-derived like the theme CSS was, so by the rule
-  // below it belongs in injectPageContent() too — a lane that doesn't run
-  // this build gets no webfont <link>s and falls back to system fonts.
-  // What blocks the move is the marker, not the principle: FONT_LINKS_MARKER
-  // has a second consumer in site/plugin.js (the vite plugin), which must not
-  // import the SSR bundle, and @uniweb/build declares no dependency on
-  // @uniweb/runtime — so there is no one place both sides can read it from
-  // today. Fixing that means giving the runtime a zero-dep leaf export for
-  // the constant and re-exporting it here. Degraded-not-broken (wrong
-  // typeface, not unstyled), which is why it was scoped out rather than
-  // rushed.
-  if (siteContent?.theme?.links && !result.includes(FONT_LINKS_MARKER)) {
-    result = result.replace(
-      '</head>',
-      `  ${FONT_LINKS_MARKER}\n${siteContent.theme.links}\n  </head>`
-    )
-  }
-
-  // Theme CSS is NOT injected here. Like the appearance boot script below, it
-  // is derived from the website graph (`website.themeData`), so it belongs to
-  // the shared seam — @uniweb/runtime/ssr's injectPageContent(), which runs
-  // just before this — and every lane gets it from one implementation. It sat
-  // here until 2026-07-28 and cloud-rendered pages were unstyled the whole
-  // time. See the "which side of the seam?" note there before adding a new
-  // head injection, and note that this file has now got it wrong twice.
+  // See the "which side of the seam?" note there before adding a new head
+  // injection, and note that this file has now got it wrong twice. The guard
+  // against a third is mechanical: tests/head-seam-parity.test.js fails if this
+  // function's <head> output gains anything outside its BUILD_ONLY allowlist.
 
   // The pre-paint appearance script is NOT injected here. It belongs to the
   // shared seam — @uniweb/runtime/ssr's injectPageContent(), which runs just