@uniweb/build 0.16.7 → 0.16.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.16.7",
+  "version": "0.16.8",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -59,15 +59,15 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
-    "@uniweb/content-writer": "0.3.3",
+    "@uniweb/theming": "0.1.15",
     "@uniweb/projections": "0.2.4",
-    "@uniweb/theming": "0.1.15"
+    "@uniweb/content-writer": "0.3.3"
   },
   "optionalDependencies": {
     "@uniweb/content-reader": "1.2.2",
-    "@uniweb/runtime": "0.9.2",
-    "@uniweb/semantic-parser": "1.2.1",
-    "@uniweb/schemas": "0.2.4"
+    "@uniweb/runtime": "0.9.3",
+    "@uniweb/schemas": "0.2.5",
+    "@uniweb/semantic-parser": "1.2.1"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/resolve-data-schema.js

@@ -600,10 +600,32 @@ function normalizeField(field, ref, path) {
 
   // Structural kinds.
   if (out.type === 'object') {
-    if (field.fields === undefined) {
-      throw new Error(`Data schema '${ref}': object field '${path}' must declare nested 'fields'.`)
+    // Two ways to describe an object, and they answer different questions:
+    //
+    //   fields  the object's KNOWN keys — `{ street, city }`
+    //   values  an OPEN MAP whose keys belong to the author and whose values all
+    //           conform to one shape — `{ <anything>: <a field spec> }`
+    //
+    // `values` is to an object what `items` is to an array, and it exists for
+    // the same reason: a form's `fields` is a map keyed by author-chosen names
+    // (see `@std/form`), which could not be described at all until this landed.
+    // Requested by the editor team 2026-07-31 — the shape they needed and could
+    // not state in this vocabulary either.
+    if (field.values !== undefined && field.fields !== undefined) {
+      throw new Error(
+        `Data schema '${ref}': object field '${path}' declares both 'fields' and 'values'. ` +
+          `Use 'fields' for known keys, 'values' for an open map — not both.`
+      )
+    }
+    if (field.values !== undefined) {
+      out.values = normalizeField(field.values, ref, `${path}{}`)
+    } else if (field.fields === undefined) {
+      throw new Error(
+        `Data schema '${ref}': object field '${path}' must declare nested 'fields' (known keys) or 'values' (an open map).`
+      )
+    } else {
+      out.fields = normalizeFields(field.fields, ref, path)
     }
-    out.fields = normalizeFields(field.fields, ref, path)
   } else if (out.type === 'array') {
     // `items` (the element type) is recommended but optional — an array with
     // no declared element type is an untyped list.
@@ -637,6 +659,7 @@ export function collectNestedRefs(schema) {
       if (typeof field.options === 'string') found.add(field.options)
       if (field.fields) walkFields(field.fields)
       if (field.items) walkFields({ _: field.items })
+      if (field.values) walkFields({ _: field.values })
     }
   }
   const walkSections = (sections) => {

package/src/validate-data.js

@@ -118,6 +118,21 @@ function validateValue(def, value, path) {
       out.push(violation(path, 'type', `expected object, got ${typeName(value)}`))
     } else if (def.fields) {
       out.push(...validateFields(def.fields, value, path))
+    } else if (def.values) {
+      // An OPEN MAP: the keys are the author's, every value conforms to one
+      // shape. `values` is to an object what `items` is to an array.
+      //
+      // Note what this deliberately does NOT do: reject a key. It cannot — the
+      // keys are the whole point — and it must not reject unexpected keys
+      // WITHIN a value either, which falls out of `validateFields` walking the
+      // schema's fields rather than the data's. That tolerance is load-bearing
+      // for `@std/form`: a form definition may carry per-field keys the current
+      // builder cannot author (hand-written, or from a newer editor), and the
+      // editor's boundary passes them through untouched. A stricter check here
+      // would fail builds on good content.
+      for (const [key, item] of Object.entries(value)) {
+        out.push(...validateValue(def.values, item, `${path}.${key}`))
+      }
     }
     return out
   }