@uniweb/build 0.14.19 → 0.14.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.14.19",
+  "version": "0.14.21",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -65,7 +65,7 @@
   "optionalDependencies": {
     "@uniweb/runtime": "0.8.20",
     "@uniweb/content-reader": "1.1.12",
-    "@uniweb/schemas": "0.2.3"
+    "@uniweb/schemas": "0.2.4"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/resolve-data-schema.js

@@ -57,21 +57,21 @@ const TYPE_ALIASES = {
 }
 // Friendly type aliases that lower to a base kind + a carried `format` marker.
 // `url`/`email` → `string` (server-validated value subtypes). `markdown`/`html` →
-// `text` (the file-based rich-content body — round-trips as the raw source string,
-// what the retired `richtext` kind used to be: 2026-06-02 / uwx-format.md).
+// `text` (a file-based rich-content body — round-trips as the raw source string).
 const FORMAT_TYPE_ALIASES = {
   url: { type: 'string', format: 'url' },
   email: { type: 'string', format: 'email' },
   markdown: { type: 'text', format: 'markdown' },
   html: { type: 'text', format: 'html' },
-  // Deprecated back-compat alias: `richtext` was a kind before 2026-06-02; it is
-  // now just sugar for the canonical `text` + `format: markdown`. Not a kind, and
-  // intentionally left out of the advertised set below.
-  richtext: { type: 'text', format: 'markdown' },
+  // `richtext` → a ProseMirror rich document (`json` + `format: prosemirror`): the
+  // framework's standard way to represent rich text — the structured, lossless form
+  // the visual app edits (text, media, tables, code, data blocks, icons, and inline
+  // components). Synced to file mode as enhanced markdown via content-writer. Contrast
+  // `markdown`/`html`, which are source-string bodies (raw text, no structured editor).
+  richtext: { type: 'json', format: 'prosemirror' },
 }
 // The advertised format-aliasing type words (drives the "Known types" hint).
-// `richtext` is accepted (above) but omitted here — no longer recommended.
-export const FORMAT_TYPES = new Set(['url', 'email', 'markdown', 'html'])
+export const FORMAT_TYPES = new Set(['url', 'email', 'markdown', 'html', 'richtext'])
 export const SECTION_KINDS = new Set(['single', 'multi', 'binder'])
 
 // Scope → schema package resolution. The shared standard schemas are referenced
@@ -324,7 +324,7 @@ export function validateAndNormalizeSchema(schema, ref) {
   }
 
   const out = {}
-  for (const k of ['name', 'version', 'description', 'sortDate']) {
+  for (const k of ['name', 'version', 'description', 'sort_date', 'sortDate']) {
     if (schema[k] !== undefined) out[k] = schema[k]
   }
 
@@ -361,7 +361,18 @@ function normalizeSection(section, ref, path, briefState) {
   if (!section || typeof section !== 'object' || Array.isArray(section)) {
     throw new Error(`Data schema '${ref}': section '${path}' must be an object.`)
   }
-  const kind = section.kind ?? 'single'
+  if (section.many !== undefined && typeof section.many !== 'boolean') {
+    throw new Error(`Data schema '${ref}': section '${path}' 'many' must be a boolean.`)
+  }
+  // Cardinality. Friendly sugar: `many: true` → a list of records; a section with
+  // only child `sections:` (no `fields:`) is a binder — inferred, never written.
+  // Explicit `kind:` is still honored (the lower-level form it normalizes to).
+  let kind = section.kind
+  if (kind === undefined) {
+    if (section.many === true) kind = 'multi'
+    else if (section.fields === undefined && section.sections !== undefined) kind = 'binder'
+    else kind = 'single'
+  }
   if (!SECTION_KINDS.has(kind)) {
     throw new Error(`Data schema '${ref}': section '${path}' has invalid kind '${kind}' (expected single | multi | binder).`)
   }
@@ -369,7 +380,7 @@ function normalizeSection(section, ref, path, briefState) {
 
   if (section.brief === true) {
     if (kind !== 'single') {
-      throw new Error(`Data schema '${ref}': brief section '${path}' must be kind 'single', not '${kind}'.`)
+      throw new Error(`Data schema '${ref}': brief section '${path}' must be a single record (drop 'many').`)
     }
     if (++briefState.count > 1) {
       throw new Error(`Data schema '${ref}': more than one section marked 'brief: true' (at most one).`)
@@ -395,18 +406,19 @@ function normalizeSection(section, ref, path, briefState) {
   }
   if (section.constraints !== undefined) out.constraints = section.constraints
 
-  // `nestable` — a self-nesting multi whose items form a tree among themselves.
-  // Carried into the IR so the submission lowering can map it to the model's
-  // `self_nesting`. The item parent/child link is internal to the backend
-  // (`parent_item_id`); no explicit field expresses it.
-  if (section.nestable !== undefined) {
-    if (typeof section.nestable !== 'boolean') {
-      throw new Error(`Data schema '${ref}': section '${path}' 'nestable' must be a boolean.`)
+  // `tree: true` (friendly) / `nestable: true` (lower-level) — a list section whose
+  // records form a tree among themselves. Carried into the IR so the lowering maps
+  // it to the model's `self_nesting`. The parent/child link is internal to the
+  // backend (`parent_item_id`); no explicit field expresses it.
+  const treeFlag = section.tree ?? section.nestable
+  if (treeFlag !== undefined) {
+    if (typeof treeFlag !== 'boolean') {
+      throw new Error(`Data schema '${ref}': section '${path}' 'tree' must be a boolean.`)
     }
-    if (section.nestable && kind !== 'multi') {
-      throw new Error(`Data schema '${ref}': section '${path}' is 'nestable: true' but kind '${kind}' — only a 'multi' section can self-nest.`)
+    if (treeFlag && kind !== 'multi') {
+      throw new Error(`Data schema '${ref}': section '${path}' is 'tree: true' but not a list — only a 'many: true' section can form a tree.`)
     }
-    if (section.nestable) out.nestable = true
+    if (treeFlag) out.nestable = true
   }
 
   // `append_only` — a multi whose records are insert-only: the backend accepts
@@ -419,7 +431,7 @@ function normalizeSection(section, ref, path, briefState) {
       throw new Error(`Data schema '${ref}': section '${path}' 'append_only' must be a boolean.`)
     }
     if (section.append_only && kind !== 'multi') {
-      throw new Error(`Data schema '${ref}': section '${path}' is 'append_only: true' but kind '${kind}' — only a 'multi' section can be append-only.`)
+      throw new Error(`Data schema '${ref}': section '${path}' is 'append_only: true' but not a list — only a 'many: true' section can be append-only.`)
     }
     if (section.append_only) out.append_only = true
   }
@@ -444,6 +456,40 @@ function normalizeField(field, ref, path) {
   if (!field || typeof field !== 'object' || Array.isArray(field)) {
     throw new Error(`Data schema '${ref}': field '${path}' must be an object or a type string.`)
   }
+
+  // Sugar: `many: true` → a list. Wrap the field-minus-`many` as the array's item
+  // type (lowers to the canonical `multiple`). The common cases —
+  // `{ ref: '@/x', many: true }`, `{ type: string, many: true }` — read as "a list
+  // of X" with no `array`/`items` ceremony.
+  if (field.many !== undefined) {
+    if (typeof field.many !== 'boolean') {
+      throw new Error(`Data schema '${ref}': field '${path}' 'many' must be a boolean.`)
+    }
+    if (field.many) {
+      // Collection-level metadata (required, default, label, help, description)
+      // rides on the array; the type-bearing attributes describe each item.
+      const ITEM_KEYS = new Set(['type', 'ref', 'options', 'enum', 'fields', 'items', 'format'])
+      const out = { type: 'array' }
+      const item = {}
+      for (const [k, v] of Object.entries(field)) {
+        if (k === 'many') continue
+        if (ITEM_KEYS.has(k)) item[k] = v
+        else out[k] = v
+      }
+      out.items = normalizeField(item, ref, `${path}[]`)
+      return out
+    }
+    const { many, ...rest } = field // many: false → a single value
+    field = rest
+  }
+
+  // Sugar: infer `type` from `ref:`/`options:` when omitted — `{ ref: '@/x' }` is a
+  // reference; `{ options: '@/x' }` is a curated picklist value.
+  if (field.type === undefined) {
+    if (typeof field.ref === 'string') field = { ...field, type: 'ref' }
+    else if (typeof field.options === 'string') field = { ...field, type: 'string' }
+  }
+
   const rawType = field.type
   if (typeof rawType !== 'string') {
     throw new Error(`Data schema '${ref}': field '${path}' has no 'type'.`)
@@ -455,8 +501,8 @@ function normalizeField(field, ref, path) {
     if (field[k] !== undefined) out[k] = field[k]
   }
 
-  // Resolve the type: format-aliases (url/email → string; markdown/html/richtext →
-  // text) carry a `format` marker; else the plain alias map; else verbatim.
+  // Resolve the type: format-aliases (url/email → string; markdown/html → text;
+  // richtext → json) carry a `format` marker; else the plain alias map; else verbatim.
   const formatAlias = FORMAT_TYPE_ALIASES[rawType]
   if (formatAlias) {
     out.type = formatAlias.type

package/src/site/content-collector.js

@@ -295,6 +295,16 @@ const CONTENT_PROFILES = {
   'document.yml': { contentDir: 'content', defaultMode: 'pages',    orderField: 'content' }
 }
 
+// Short profile aliases, so a caller that knows its own context can select
+// the profile explicitly (collectSiteContent's `profile` option) instead of
+// inferring it from the config filename. unipress — always a document tool —
+// uses this so an author can name a variant config anything (book.yml,
+// print.yml) without it being misread as a site.
+const PROFILE_ALIASES = {
+  document: CONTENT_PROFILES['document.yml'],
+  site: CONTENT_PROFILES['site.yml']
+}
+
 function getContentProfile(configFile) {
   return CONTENT_PROFILES[configFile] || CONTENT_PROFILES['site.yml']
 }
@@ -1974,17 +1984,18 @@ async function collectLayouts(layoutDir, siteRoot, layoutNames = new Set()) {
  * @param {Object} options - Collection options
  * @param {string} options.foundationPath - Path to foundation directory (for theme vars)
  * @param {string} [options.configFile='site.yml'] - Name of the top-level config file inside sitePath. Defaults to 'site.yml'. Document tools (unipress) pass 'document.yml'.
+ * @param {'document'|'site'} [options.profile] - Explicit content profile, authoritative over the filename. Lets a tool that knows its context (unipress → 'document') read an arbitrarily named config with the right directory/mode/ordering. Falls back to the configFile-derived profile when omitted.
  * @returns {Promise<Object>} Site content object with assets manifest
  */
 export async function collectSiteContent(sitePath, options = {}) {
-  const { foundationPath, configFile = 'site.yml' } = options
+  const { foundationPath, configFile = 'site.yml', profile: profileName } = options
 
   // Read site config and raw theme config
   const siteConfig = await readYamlFile(join(sitePath, configFile))
 
   // Profile selects workspace-root defaults: site.yml → pages/ + page mode +
   // pages: ordering; document.yml → content/ + folder mode + content: ordering.
-  const profile = getContentProfile(configFile)
+  const profile = (profileName && PROFILE_ALIASES[profileName]) || getContentProfile(configFile)
 
   // Resolve content paths from <config>.paths: group, defaulting per profile.
   // Backward compatibility: when the document profile's `content/` is missing

package/src/uwx/data-schema.js

@@ -194,16 +194,21 @@ function lowerField(rawField, resolve, optResolve) {
     return out
   }
 
-  // A leaf (scalar) kind. `richtext` is retired (2026-06-02 / uwx-format.md): a
-  // leftover `richtext` in the IR (e.g. a foundation built before the migration)
-  // lowers to the file-based body shape — `text` + `format: markdown` — so the wire
-  // never carries the kind the backend now rejects.
-  let leafType = type
-  let leafFormat = field.format
-  if (leafType === 'richtext') {
-    leafType = 'text'
-    leafFormat = leafFormat ?? 'markdown'
+  // A leaf (scalar) kind. `richtext` is NOT a kind — it is the author alias for a
+  // ProseMirror document (`json` + `format: prosemirror`), normalized upstream in
+  // resolve-data-schema.js, so normalized IR never carries a raw `richtext` kind. The
+  // only way one could reach here is a STALE prebuilt schema.json (a foundation built
+  // before the 2026-06-02 kind retirement and loaded from dist/meta/schema.json without
+  // re-resolving). Fail locally — rebuild the foundation — rather than ship a kind the
+  // backend rejects.
+  if (type === 'richtext') {
+    throw new Error(
+      'This foundation carries the retired `richtext` kind in its built schema — ' +
+        'rebuild it (`richtext` is now json + format: prosemirror).'
+    )
   }
+  const leafType = type
+  const leafFormat = field.format
 
   const out = { type: leafType }
   if (field.label) out.label = field.label