@uniweb/build 0.34.0 → 0.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "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/schemas": "^0.2.13",
-    "@uniweb/content-reader": "^1.2.4",
+    "@uniweb/projections": "^0.5.6",
     "@uniweb/theming": "^0.1.15",
     "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/projections": "^0.5.5",
-    "@uniweb/content-writer": "^0.3.4"
+    "@uniweb/content-writer": "^0.3.4",
+    "@uniweb/content-reader": "^1.2.4",
+    "@uniweb/schemas": "^0.2.13"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.13.6"
+    "@uniweb/runtime": "^0.13.7"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -76,7 +76,7 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "^0.17.0"
+    "@uniweb/core": "^0.18.0"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/site/data-fetcher.js

@@ -253,11 +253,11 @@ export function applyPostProcessing(data, config) {
 const RECOGNIZED_FETCH_KEYS = {
   refine: new Set(['refine', 'inherit', 'detail', 'limit', 'sort', 'where', 'filter']),
   query: new Set([
-    'query', 'schema', 'prerender', 'merge', 'transform',
+    'query', 'as', 'schema', 'prerender', 'merge', 'transform',
     'where', 'limit', 'sort', 'detailPage', 'filter',
   ]),
   source: new Set([
-    'path', 'url', 'schema', 'prerender', 'merge', 'transform', 'detail',
+    'path', 'url', 'as', 'schema', 'prerender', 'merge', 'transform', 'detail',
     'detailPage', 'where', 'limit', 'sort', 'filter',
   ]),
 }
@@ -288,11 +288,13 @@ export function parseFetchConfig(fetch) {
 
   // Simple string: "/data/team.json"
   if (typeof fetch === 'string') {
-    const schema = inferSchemaFromPath(fetch)
+    const inferred = inferSchemaFromPath(fetch)
     return {
       path: fetch,
       url: undefined,
-      schema,
+      // Both spellings — see the note in the named-query branch below.
+      as: inferred,
+      schema: inferred,
       prerender: true,
       merge: false,
       transform: undefined,
@@ -368,10 +370,27 @@ export function parseFetchConfig(fetch) {
       query: fetch.query,
       path: queryDataUrl(fetch.query),
       url: undefined,
-      // The BINDING KEY — the `content.data.<key>` a component reads. Defaults to
-      // the query name, which is why the two were confusable; `query` above now
-      // carries the identity so this one only has to carry the key.
-      schema: fetch.schema || fetch.query,
+      // ⭐ **`as`, not `schema`.** The BINDING KEY — the `content.data.<key>` a
+      // component reads — defaults to the query name. It was called `schema`
+      // until 2026-09-02, which collided with the MODEL REF of the same name on a
+      // `queries` declaration; `fetch.schema` is still accepted as input so
+      // existing content keeps working, and is never emitted.
+      // ⛔ **BOTH SPELLINGS ARE EMITTED, and this is not the overload coming back.**
+      // `bindingKey()` reads `as ?? schema`, so NEW core needs only `as`. But a
+      // published site renders at ITS OWN pinned runtime version, and every
+      // runtime shipped to date bundles a core whose resolver does
+      // `if (!cfg?.schema) continue` — so an `as`-only payload served by an older
+      // runtime is SKIPPED ENTIRELY. No data, nothing thrown, nothing logged.
+      //
+      // ⭐ The compatibility runs the OTHER WAY from `bindingKey`'s: that one is
+      // old payloads meeting new code, this one is new payloads meeting old code,
+      // and only the first was covered. Caught by frontend before it shipped.
+      //
+      // ⇒ Emit both until every serving runtime carries `bindingKey`, then drop
+      // `schema` here. Until then a reader may see this as redundant; it is a
+      // compatibility duplicate and the comment is what tells them apart.
+      as: fetch.as || fetch.schema || fetch.query,
+      schema: fetch.as || fetch.schema || fetch.query,
       prerender: fetch.prerender ?? true,
       merge: fetch.merge ?? false,
       transform: fetch.transform,
@@ -391,6 +410,7 @@ export function parseFetchConfig(fetch) {
   const {
     path,
     url,
+    as,
     schema,
     prerender = url ? false : true,
     merge = false,
@@ -413,7 +433,9 @@ export function parseFetchConfig(fetch) {
   return {
     path,
     url,
-    schema: schema || inferSchemaFromPath(path || url),
+    // Both spellings — see the note in the named-query branch above.
+    as: as ?? schema ?? inferSchemaFromPath(path || url),
+    schema: as ?? schema ?? inferSchemaFromPath(path || url),
     prerender,
     merge,
     transform,

package/src/uwx/site.js

@@ -263,7 +263,14 @@ function buildPageData(config, ctx) {
     // validating — so `fetch` is a blob they carry and framework owns its
     // vocabulary. ⇒ There was nothing to coordinate, and inventing a coordination
     // is how a name stays wrong.
-    fetch = { query, path: queryDataUrl(query), schema: query, ...rest }
+    // ⛔ `as`, the BINDING KEY — not to be confused with `schema` at
+    // DECL_EMITTED_ABOVE / `setIf(data,'schema',d.schema)` below, which is a
+    // queries decl's MODEL REF and keeps its name. One word meant both until
+    // 2026-09-02; this is the half that moved.
+    // Both spellings, deliberately — an `as`-only payload is skipped entirely by
+    // any runtime older than `bindingKey` (`if (!cfg?.schema) continue`), with no
+    // data and no error. Drop `schema` when every serving runtime carries it.
+    fetch = { query, path: queryDataUrl(query), as: query, schema: query, ...rest }
   }
   setIf(data, 'fetch', fetch)
   if (isDynamic) {

package/src/validate-data.js

@@ -104,7 +104,7 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
       if (!type) return
       const bindings = foundation[type]?.data
       for (const input of collectInputs(section, page.fetch, config.fetch)) {
-        const key = input.schema // the content.data KEY (the `fetch.schema` field is mis-named)
+        const key = input.as ?? input.schema // the content.data KEY; `schema` is its pre-2026-09-02 name
 
         if (input.url) {
           deferred.push({ route: page.route, section: type, key, reason: 'remote url: source', url: input.url })
@@ -437,8 +437,14 @@ async function loadStandardSchemas() {
 function collectInputs(section, pageFetch, siteFetch) {
   const byKey = new Map()
   for (const f of [siteFetch, pageFetch, section.fetch]) {
-    if (f && (f.path || f.url) && typeof f.schema === 'string') {
-      byKey.set(f.schema, f)
+    // ⛔ The binding key is `as`; `schema` is its pre-2026-09-02 name and still
+    // arrives on stored payloads. A gate on the old name alone silently yields
+    // NOTHING here — no inputs collected, no violations found, a green run — which
+    // is exactly how this was caught: the integration test went from flagging the
+    // seeded violations to flagging none.
+    const key = f?.as ?? f?.schema
+    if (f && (f.path || f.url) && typeof key === 'string') {
+      byKey.set(key, f)
     }
   }
   return [...byKey.values()]