@uniweb/build 0.63.1 → 0.63.3

package/package.json

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

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/uwx/records-project.js

@@ -41,7 +41,7 @@ import yaml from 'js-yaml'
 import { YAML_OPTIONS } from '../utils/yaml-schema.js'
 import { parseFrontmatter } from './entity-source.js'
 import { writeRecordFile, writeQueriesConfig, writeRecordsConfig } from './project-writer.js'
-import { defaultSchema, deferredFromSchema, foundationDataSchemas, foundationSchemaJson } from './queries-config.js'
+import { defaultSchema, deferredFromSchema, foundationDataSchemas, foundationSchemaJson, QUERIES_YML_RELPATH } from './queries-config.js'
 import { dataKeyTypes } from './data-key-types.js'
 import { poolDirsForSchema, schemaForPoolDirs, resolveRecordsDir } from '../site/entity-pool.js'
 import { folderYmlPath } from '../site/records-config.js'
@@ -283,7 +283,7 @@ function isDerivedDeferred(d, dataSchemas) {
   return d.deferred.every((f) => a.has(f))
 }
 
-function declToFileShape(wire, dataSchemas = null, scope = null, own = null, keyTypes = null) {
+function declToFileShape(wire, dataSchemas = null, scope = null, own = null, keyTypes = null, authored = null) {
   // ⛔ UNDO THE PRODUCER'S QUALIFICATION FIRST, before anything compares against
   // `schema`. The push qualifies a foundation-relative `@/x` to `@scope/x`
   // (`site.js::queriesNested`), and both checks below are keyed by the author's
@@ -317,8 +317,14 @@ function declToFileShape(wire, dataSchemas = null, scope = null, own = null, key
   // The default is the query's name — or, when no data schema has that name, the type the
   // foundation declares for the data key of that name (`data-key-types.js`), which is what a
   // push sent in its place. Either one stays unwritten, so the terse file stays terse.
+  // ⛔ UNLESS THE AUTHOR WROTE IT: a `schema:` the local file already states for this query is
+  // written back as it is. Until 2026-09-25 a pull into a working copy dropped international's
+  // `articles: { schema: '@std/article' }`, because a section types `articles` as `@std/article`.
   const keyDefault = name && !own?.has(name) ? keyTypes?.get(name) : null
-  if (d.schema && d.schema !== defaultSchema(name) && d.schema !== keyDefault) decl.schema = d.schema
+  const written = name ? authored?.get(name) : undefined
+  if (d.schema && (d.schema === written || (d.schema !== defaultSchema(name) && d.schema !== keyDefault))) {
+    decl.schema = d.schema
+  }
   setIf(decl, 'sort', d.sort)
   setIf(decl, 'where', d.where)
   setIf(decl, 'limit', d.limit)
@@ -383,6 +389,26 @@ function declToFileShape(wire, dataSchemas = null, scope = null, own = null, key
  *        (`info.foundation`, the pinned `@org/name@version`), which is that scope.
  * @returns {{ collections?: 'updated'|'unchanged' }}
  */
+// The `schema:` each query's author wrote, by query name — `queries.yml` over `site.yml::queries`,
+// the precedence the build reads them in. A query written without one is absent.
+function authoredQuerySchemas(siteRoot, siteYml) {
+  let file = null
+  try {
+    file = yaml.load(readFileSync(join(siteRoot, QUERIES_YML_RELPATH), 'utf8'), YAML_OPTIONS)
+  } catch {
+    file = null
+  }
+  const out = new Map()
+  for (const decls of [siteYml?.queries, file]) {
+    if (!decls || typeof decls !== 'object') continue
+    for (const [name, decl] of Object.entries(decls)) {
+      if (typeof decl?.schema === 'string') out.set(name, decl.schema)
+      else if (out.has(name)) out.delete(name)
+    }
+  }
+  return out
+}
+
 export function declarationsToQueriesYml({ document, siteRoot, scope, ...rest }) {
   refuseOrgOption(rest, 'declarationsToQueriesYml')
   const decls = Array.isArray(document?.queries) ? document.queries : []
@@ -408,10 +434,11 @@ export function declarationsToQueriesYml({ document, siteRoot, scope, ...rest })
   // (`unresolveSelfScope`) — and the types of its data keys.
   const own = ownSchemaNames(dataSchemas)
   const keyTypes = siteYml ? dataKeyTypes(foundationSchemaJson(siteRoot, siteYml)) : null
+  const authored = authoredQuerySchemas(siteRoot, siteYml)
 
   const queries = {}
   for (const d of decls) {
-    const { name, decl } = declToFileShape(d, dataSchemas, selfScope, own, keyTypes)
+    const { name, decl } = declToFileShape(d, dataSchemas, selfScope, own, keyTypes, authored)
     if (!name) continue
     queries[name] = decl
   }

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 {