@uniweb/build 0.63.1 → 0.63.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.63.1",
+  "version": "0.63.2",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -58,11 +58,11 @@
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
     "@uniweb/content-reader": "^1.2.5",
+    "@uniweb/projections": "^0.7.3",
     "@uniweb/content-writer": "^0.3.4",
     "@uniweb/schemas": "^0.7.0",
-    "@uniweb/projections": "^0.7.3",
-    "@uniweb/semantic-parser": "^1.4.1",
-    "@uniweb/theming": "^0.1.15"
+    "@uniweb/theming": "^0.1.15",
+    "@uniweb/semantic-parser": "^1.4.1"
   },
   "optionalDependencies": {
     "@uniweb/runtime": "^0.27.4"

package/src/uwx/data-key-types.js

@@ -19,9 +19,10 @@
 import { declaredKeys } from '@uniweb/core/data-keys'
 
 /**
- * The type each data key of a foundation's section types names, where every declaration of the
- * key agrees on one — from its built `schema.json`, whose section types sit at the top level
- * beside `_self` and `dataSchemas`, each with its `data:`.
+ * The type each data key of a foundation names, where every declaration of the key agrees on
+ * one — from its built `schema.json`: each section type's `data:` (at the top level, beside
+ * `_self` and `dataSchemas`), each layout's (under `_layouts`), and the foundation's own, which
+ * reaches every section (`main.js` `data:`, under `_self`).
  *
  * @param {object|null} foundationSchema - a foundation's built `dist/meta/schema.json`
  * @returns {Map<string, string>} data key → its schema ref (`team` → `@/member`)
@@ -29,14 +30,19 @@ import { declaredKeys } from '@uniweb/core/data-keys'
 export function dataKeyTypes(foundationSchema) {
   const types = new Map()
   const conflicted = new Set()
-  for (const [name, entry] of Object.entries(foundationSchema || {})) {
-    if (name === '_self' || name === 'dataSchemas' || !entry || typeof entry !== 'object') continue
-    for (const [key, ref] of declaredKeys(entry.data)) {
+  const declare = (data) => {
+    for (const [key, ref] of declaredKeys(data)) {
       if (!ref) continue
       if (types.has(key) && types.get(key) !== ref) conflicted.add(key)
       else types.set(key, ref)
     }
   }
+  for (const [name, entry] of Object.entries(foundationSchema || {})) {
+    if (!entry || typeof entry !== 'object' || name === 'dataSchemas') continue
+    if (name === '_self') declare(entry.data)
+    else if (name === '_layouts') for (const layout of Object.values(entry)) declare(layout?.data)
+    else if (!name.startsWith('_')) declare(entry.data)
+  }
   for (const key of conflicted) types.delete(key)
   return types
 }

package/src/validate-data.js

@@ -41,6 +41,7 @@ import { validateAndNormalizeSchema, buildDataSchemaMap } from './resolve-data-s
 export { validateItem, isStaticallyCheckable } from '@uniweb/schemas/conform'
 import { buildSchema } from './schema.js'
 import { resolveRecordsDir, readEntityPool, groupPoolBySchema } from './site/entity-pool.js'
+import { dataKeyTypes, keyOfDefaultRef } from './uwx/data-key-types.js'
 import { readEntityFile } from './uwx/entity-source.js'
 import { toFetchList } from './site/data-fetcher.js'
 import { resolveFoundationSrcPath } from './utils/foundation-source-root.js'
@@ -86,6 +87,9 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
   const srcDir = resolveFoundationSrcPath(foundationPath)
   const foundation = await buildSchema(srcDir)
   const dataSchemas = foundation.dataSchemas || {}
+  // The type each data key names — a records folder named for a typed key holds records of
+  // that type when no data schema has its name (`uwx/data-key-types.js`).
+  const keyTypes = dataKeyTypes(foundation)
 
   const site = await collectSiteContent(siteRoot, { foundationPath })
   const config = site.config || {}
@@ -275,7 +279,7 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
   // its folder names. ⭐ The set a push sends: every file in the records directory is
   // a record and every record is pushed, whether or not a section reads it — and
   // until 2026-09-24 one that no section read was never checked here.
-  const files = await validateRecordFiles(siteRoot, { srcDir, dataSchemas, paths: config.paths, checked: checkedRecords })
+  const files = await validateRecordFiles(siteRoot, { srcDir, dataSchemas, keyTypes, paths: config.paths, checked: checkedRecords })
   violations.push(...files.violations)
   setupErrors.push(...files.setupErrors)
   for (const ref of files.schemas) schemasSeen.add(ref)
@@ -321,22 +325,34 @@ function listViolation(finding, label, base) {
  * that names no record of its schema is reported under the rule `ref`, since a push
  * cannot send it.
  *
- * A folder whose schema resolves to nothing is left out in silence: its records are
- * schema-less, delivered as files, and the push says so itself.
+ * ⭐ A folder named for a data key the foundation types, when no data schema has its name,
+ * holds records of that type and is checked against it — `records/team/` against `@/member`
+ * for `data: { team: '@/member' }` — the way a push sends them [Diego, 2026-09-25]
+ * (`uwx/data-key-types.js`). A folder whose schema resolves to nothing even so is left out in
+ * silence: its records are schema-less, delivered as files, and the push says so itself.
  *
  * @returns {Promise<{ violations: object[], setupErrors: object[], schemas: Set<string>, checked: number }>}
  */
-async function validateRecordFiles(siteRoot, { srcDir, dataSchemas, paths, checked }) {
+async function validateRecordFiles(siteRoot, { srcDir, dataSchemas, keyTypes = new Map(), paths, checked }) {
   const out = { violations: [], setupErrors: [], schemas: new Set(), checked: 0 }
   const pool = await readEntityPool(siteRoot, { dir: resolveRecordsDir(siteRoot, paths).rel })
   // Every record is read first: a reference names a record of another schema by its
   // name — its file's, or its `slug:` — or by the id its file carries.
   const read = []
   const names = new Map() // schema (as its folder names it) → the names and ids of its records
-  for (const [ref, entities] of groupPoolBySchema(pool.entities)) {
-    const schema = await schemaForRecords(ref, { srcDir, dataSchemas })
+  for (const [folderRef, entities] of groupPoolBySchema(pool.entities)) {
+    let ref = folderRef
+    let schema = await schemaForRecords(folderRef, { srcDir, dataSchemas })
+    const typed = schema ? null : keyTypes.get(keyOfDefaultRef(folderRef))
+    if (typed) {
+      schema = await schemaForRecords(typed, { srcDir, dataSchemas })
+      if (schema) ref = typed
+    }
+    // Records are named under what they ARE — a reference to `@/member` finds the ones kept
+    // in `records/team/` — and under the folder's own ref as well.
     const known = names.get(ref) ?? new Set()
     names.set(ref, known)
+    if (ref !== folderRef) names.set(folderRef, known)
     for (const pooled of entities) {
       let records
       try {