@uniweb/build 0.63.4 → 0.64.1

package/src/uwx/records.js

@@ -44,6 +44,7 @@ import { readFileSync, existsSync } from 'node:fs'
 import yaml from 'js-yaml'
 import { YAML_OPTIONS } from '../utils/yaml-schema.js'
 import { detectFoundationType } from '../site/foundation-ref.js'
+import { foundationSchemaJson } from '../site/queries-config.js'
 import { join, resolve } from 'node:path'
 
 import { resolveQueriesConfig } from './queries-config.js'
@@ -55,14 +56,14 @@ import {
   poolPathReadings,
   poolDirsForSchema,
 } from '../site/entity-pool.js'
-import { toDataSchemaDeclaration, isProseMirrorField, isMarkupTextField } from './data-schema.js'
+import { toDataSchemaDeclaration, isProseMirrorField, isMarkupTextField, isOpenMapSection, openMapEntries } from './data-schema.js'
 import { recordFileLayout, contentBodyTarget } from './record-layout.js'
 import { emitEntitySyncPackage } from './entity-document.js'
 import { resolveSelfScope, siteSelfScope, refuseOrgOption } from './self-scope.js'
 import { sha256Hex, toJsonBuffer } from './manifest.js'
 import { isUuid } from './uuid.js'
 import { markdownToProseMirror } from '@uniweb/content-reader'
-import { LOCALIZED_FIELD_ASSUMPTION, localize } from './localize.js'
+import { LOCALIZED_FIELD_ASSUMPTION } from './localize.js'
 import { localizeScalar, localizeScalarList, localizeContentDoc, loadLocaleTranslations, discoverLocales, discoverFreeformLocales, localesDir, isLocalizedContent } from './locale-sync.js'
 import { loadFreeformRecord } from '../i18n/freeform.js'
 import { isDraftRecord } from '../site/record-draft.js'
@@ -164,7 +165,10 @@ export function entityContentHash(document) {
   return sha256Hex(toJsonBuffer(stripSigils(document)))
 }
 
-function encodeFieldValue(value, field, sourceLocale, translations) {
+// ⭐ `context` is the record the value is in — `{ key: '<pool>/<handle>' }`, the identity its
+// translations are kept under (`i18n/records.js`) — so an entry that reads differently in some
+// records (`{ default, overrides }`) is sent as each one renders it.
+function encodeFieldValue(value, field, sourceLocale, translations, context = null) {
   if (value == null) return value
   if (isProseMirrorField(field)) {
     // markdown source → ProseMirror doc. When localized, wrap per-locale exactly
@@ -172,7 +176,7 @@ function encodeFieldValue(value, field, sourceLocale, translations) {
     // path, flushed to locales/records/{locale}.json by the caller.
     const doc = typeof value === 'string' ? markdownToProseMirror(value) : value
     if (!field.localized) return doc
-    const localized = localizeContentDoc(doc, sourceLocale, Object.keys(translations || {}), translations)
+    const localized = localizeContentDoc(doc, sourceLocale, Object.keys(translations || {}), translations, context)
     // localizeContentDoc returns a BARE doc when there are no target locales. A
     // localized field MUST ride as a `{ lang: value }` map on the wire — the
     // schema-driven projector drops a localized field whose value isn't a map — so
@@ -184,15 +188,14 @@ function encodeFieldValue(value, field, sourceLocale, translations) {
     // element — the shape page `keywords` already take. ⛔ It went up as a bare list
     // until 2026-09-24: `localizeScalar` passes any object through, arrays included.
     if (Array.isArray(value) && !isMarkupTextField(field)) {
-      return localizeScalarList(value, sourceLocale, translations)
+      return localizeScalarList(value, sourceLocale, translations, context)
     }
-    // A markup `text` BODY (format markdown|html) rides as a RAW string, wrapped
-    // per-locale wholesale (its per-string translations live in the i18n manifest /
-    // free-form, not the scalar map). Other localized scalars wrap per-string from
-    // locales/records/{locale}.json.
-    return isMarkupTextField(field)
-      ? localize(value, sourceLocale)
-      : localizeScalar(value, sourceLocale, translations)
+    // A markup `text` field (format markdown|html) rides as its RAW source, and its
+    // translation is the one the build renders: the whole value, keyed by the value
+    // (`i18n/records.js` extracts and translates it as one unit) — so it is wrapped
+    // per string like any localized scalar. ⛔ Until 2026-09-26 it went up as its
+    // source alone (`{ en }`), though the static build rendered its translation.
+    return localizeScalar(value, sourceLocale, translations, context)
   }
   // A Date handed in by a caller. The backend validates `date` as `YYYY-MM-DD` and
   // `datetime` as RFC3339 — emitting full ISO for a `date` field is rejected before
@@ -266,6 +269,25 @@ export function recordsToEntities({
         `"${bodyTarget.section}.${bodyTarget.key}"`
     )
   }
+  // ⛔ A SITE'S FOLDER PLACES ONLY A RECORD SOMETHING CAN REFERENCE. A folder entry is a
+  // reference, and a Model with no brief is not linkable (`toDataSchemaDeclaration`), so a
+  // backend refuses to place its records — measured 2026-09-25 as a `409 … linkable: false`,
+  // and by design (backend, 2026-09-26). Refused here, once for the schema, before anything
+  // is sent — and saying why, which the backend's refusal names only by its design doc.
+  if (declaration.linkable === false) {
+    const slugs = (records || []).map((r) => r?.slug).filter(Boolean)
+    if (slugs.length) {
+      const named = slugs.slice(0, 3).join(', ') + (slugs.length > 3 ? ` and ${slugs.length - 3} more` : '')
+      refusals.push(
+        `${label}: ${declaration.name} has no brief, so a site's folder cannot place its records ` +
+          `(${named}) — a folder entry is a reference, and only a record of a schema with a brief ` +
+          'can be one. Give the schema a brief (`brief: true` on one of its sections), or keep this ' +
+          'data out of records/.'
+      )
+    }
+    return { entities, warnings, refusals }
+  }
+
   for (const record of records || []) {
     const slug = record.slug
     if (!slug) {
@@ -291,14 +313,15 @@ export function recordsToEntities({
     const uuid = record.$uuid || null
     const hasBody = typeof record.$body === 'string' && record.$body.trim() !== ''
 
-    const enc = encoder(sourceLocale, translations, refs)
+    const context = { key: `${label}/${slug}` } // as the build keys the record's translations
+    const enc = encoder(sourceLocale, translations, refs, context)
     const sections = layout.flat ? readFlat(layout, record, enc) : readBySection(layout, record, enc)
     // The markdown body fills the content body field, in whatever section declares it,
     // unless the file already sets that field.
     if (hasBody && bodyTarget) {
       const data = (sections[bodyTarget.section] ??= {})
       if (data[bodyTarget.key] == null) {
-        data[bodyTarget.key] = encodeFieldValue(record.$body, bodyTarget.field, sourceLocale, translations)
+        data[bodyTarget.key] = encodeFieldValue(record.$body, bodyTarget.field, sourceLocale, translations, context)
       }
     }
     // The brief is the card, and is always sent — an empty one included, so a required
@@ -381,8 +404,8 @@ export function recordsToEntities({
 // What one record's read collects beside the values: the keys with no place in the
 // schema, the keys written flat in a schema written by section, and values of the
 // wrong shape for their section.
-function encoder(sourceLocale, translations, refs = null) {
-  return { sourceLocale, translations, refs, undeclared: [], misplaced: [], shape: [], unresolved: [], namesNew: 0 }
+function encoder(sourceLocale, translations, refs = null, context = null) {
+  return { sourceLocale, translations, refs, context, undeclared: [], misplaced: [], shape: [], unresolved: [], namesNew: 0 }
 }
 
 // A flat record: its keys, minus the record's own, are the one section's fields.
@@ -426,6 +449,20 @@ function readBySection(layout, record, enc) {
 // are its child sections), a list of records for a `many` one.
 function encodeSection(def, value, enc, path) {
   if (def.multiple === true) {
+    // ⭐ AN OPEN MAP is the author's map in a file and rows on the wire (`isOpenMapSection`): each
+    // key becomes its row's `name`. ⛔ Until 2026-09-26 the map was refused as "a list of records",
+    // so no record holding one could be pushed. Rows written as a list are read as they are.
+    if (isOpenMapSection(def) && isPlainObject(value)) {
+      const rows = []
+      for (const { key, value: entry, row } of openMapEntries(value)) {
+        if (!isPlainObject(entry)) {
+          enc.shape.push(`"${path}.${key}" is one entry of a map — write it as a map of its fields.`)
+          continue
+        }
+        rows.push(encodeItem(def, row, enc, `${path}.${key}`))
+      }
+      return rows
+    }
     if (!Array.isArray(value)) {
       enc.shape.push(`"${path}" holds a list of records — write it as a list ("- …" under "${path}:").`)
       return undefined
@@ -473,7 +510,7 @@ function encodeRecord(fields, value, enc, prefix, reserved) {
         ? encodeSection(field, v, enc, `${prefix}${key}`)
         : field?.type === 'entity_ref'
           ? encodeReference(v, field, enc, `${prefix}${key}`)
-          : encodeFieldValue(v, field, enc.sourceLocale, enc.translations)
+          : encodeFieldValue(v, field, enc.sourceLocale, enc.translations, enc.context)
     if (encoded !== undefined) out[key] = encoded
   }
   for (const key of Object.keys(value)) {
@@ -754,6 +791,17 @@ function resolveFoundationDir(siteRoot, opts) {
   }
 }
 
+// The site's foundation's schema as a project keeps it for a catalog ref (`foundationSchemaJson`,
+// `site/registered-foundation.js`) — its section types, which is all this is read for.
+function registeredFoundationSchema(siteRoot) {
+  try {
+    const siteYml = yaml.load(readFileSync(join(siteRoot, 'site.yml'), 'utf8'), YAML_OPTIONS) || {}
+    return foundationSchemaJson(siteRoot, siteYml)
+  } catch {
+    return null
+  }
+}
+
 // Load the local foundation's built schema.json (the source of locally-defined
 // Model declarations), or null when there's no local foundation. `required` (set
 // when no remote resolver is available) turns "missing" into a helpful error
@@ -985,7 +1033,8 @@ export async function buildRecordEntities(siteRoot, opts = {}) {
   // holds records of that type. `keyTyped` records each such name for the `queries` Section,
   // which must name the same data schema (`sync-package.js` hands it on). ⛔ Never for a schema
   // a query asked for explicitly: that one is the author's, and fails loudly.
-  const keyTypes = dataKeyTypes(localSchema)
+  // A clone has no local foundation: its section types come from the registered version it keeps.
+  const keyTypes = dataKeyTypes(localSchema || registeredFoundationSchema(siteRoot))
   const keyTyped = new Map()
   const typedFor = async (schema) => {
     const key = keyOfDefaultRef(schema)

package/src/uwx/same-content.js

@@ -0,0 +1,43 @@
+// Do two renderings of an author's content say the same thing? A pull that changes nothing must leave
+// the author's file as they wrote it, and the writer's formatting is not theirs — so a pull compares
+// meaning, not text, before it writes.
+//
+// A leaf, so the writers that compare this way — `project-writer.js` (sections, YAML config, record
+// files), `locale-sync.js` (free-form translations) and `records-project.js` (list files) — share one
+// rule without importing each other.
+
+import { markdownToProseMirror } from '@uniweb/content-reader'
+
+const isPlainObject = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v)
+
+/** JSON with every object's keys sorted — equal for equal values, whatever the order. */
+export const canonicalJson = (value) =>
+  JSON.stringify(value, (_, v) =>
+    isPlainObject(v) ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, v[k]])) : v
+  )
+
+/**
+ * Does this markdown parse to `doc`, the way a push parses it?
+ *
+ * @param {string} markdown - an author's markdown body
+ * @param {object} doc - a ProseMirror document
+ * @returns {boolean}
+ */
+export function sameMarkdownDocument(markdown, doc) {
+  try {
+    return canonicalJson(withoutDefaults(markdownToProseMirror(markdown))) === canonicalJson(withoutDefaults(doc))
+  } catch {
+    return false
+  }
+}
+
+// A document without the attributes that only restate a default: an inset's `embedKind: 'visual'`,
+// which the parser writes and the pull's re-inlining leaves out (`reinlineInsets`) — so a body holding
+// an inset never compared as unchanged (measured 2026-09-26 on the `marketing` template's hero).
+function withoutDefaults(doc) {
+  return JSON.parse(JSON.stringify(doc), (_, v) => {
+    if (v?.type !== 'inset_ref' || v.attrs?.embedKind !== 'visual') return v
+    const { embedKind: _visual, ...attrs } = v.attrs
+    return { ...v, attrs }
+  })
+}