@uniweb/build 0.36.0 → 0.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.36.0",
+  "version": "0.37.1",
   "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/semantic-parser": "^1.4.0",
     "@uniweb/content-writer": "^0.3.4",
-    "@uniweb/theming": "^0.1.15",
     "@uniweb/content-reader": "^1.2.4",
+    "@uniweb/semantic-parser": "^1.4.0",
+    "@uniweb/projections": "^0.5.7",
     "@uniweb/schemas": "^0.2.13",
-    "@uniweb/projections": "^0.5.7"
+    "@uniweb/theming": "^0.1.15"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.14.0"
+    "@uniweb/runtime": "^0.14.2"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/prerender.js

@@ -567,8 +567,7 @@ export async function prerenderSite(siteDir, options = {}) {
     initPrerender,
     hydrateDataStore,
     prefetchIcons,
-    renderPage,
-    injectPageContent,
+    createPageRenderer,
     generate404Html,
   } = await import('@uniweb/runtime/ssr')
 
@@ -702,6 +701,10 @@ export async function prerenderSite(siteDir, options = {}) {
     // Initialize the Uniweb runtime using the shared SSR module
     const uniweb = initPrerender(siteContent, foundation, loadedExtensions, { onProgress })
 
+    // One renderer for this run: the Website is already built and the shell is
+    // fixed, so it is created once and asked per page.
+    const renderer = createPageRenderer({ website: uniweb.activeWebsite, shell: htmlShell })
+
     // Build-specific: pre-populate DataStore so EntityStore can resolve data during prerender.
     // hydrateDataStore handles cache-key derivation + value-shape wrapping
     // — same helper used by the browser SPA boot and by the Cloudflare
@@ -765,28 +768,37 @@ export async function prerenderSite(siteDir, options = {}) {
 
       onProgress(`Rendering ${outputRoute}...`)
 
-      const result = renderPage(page, website)
-
-      if (result.error) {
-        if (result.error.type === 'hooks' || result.error.type === 'null-component') {
+      // ⭐ `renderer.render` IS the sequence this loop used to spell out —
+      // renderPage → classify → injectPageContent. It was moved into
+      // `@uniweb/runtime/ssr` because an SSR isolate assembles the same three steps
+      // per request, and two hand-written copies of one sequence is how the two
+      // lanes drift. This lane passes the Page it already holds; the isolate passes
+      // a route. See `runtime/src/page-renderer.js` for what it leaves to the host.
+      const result = renderer.render(page)
+
+      if (result.outcome === 'failed') {
+        const { type, message } = result.error
+        if (type === 'hooks' || type === 'null-component') {
           console.warn(
-            `  Skipped SSG for ${outputRoute} — ${result.error.message}. ` +
+            `  Skipped SSG for ${outputRoute} — ${message}. ` +
             `The page will render correctly client-side.`
           )
         } else {
-          console.warn(`  Warning: Failed to render ${outputRoute}: ${result.error.message}`)
+          console.warn(`  Warning: Failed to render ${outputRoute}: ${message}`)
         }
+        continue
+      }
 
-        if (process.env.UNIWEB_DEBUG) {
-          // renderPage swallows the stack, but the classification message is informative
-        }
+      // ⛔ `notFound` cannot happen here — this loop iterates pages it already has,
+      // so `render` never resolves. Handled anyway: silently writing nothing for a
+      // page the loop selected would be the same shape of empty-success bug that
+      // `renderPage`'s content-not-loaded guard exists to catch.
+      if (result.outcome === 'notFound') {
+        console.warn(`  Warning: ${outputRoute} resolved to no page; skipped`)
         continue
       }
 
-      // Shared injection: #root, title, meta, section override CSS
-      let html = injectPageContent(htmlShell, result.renderedContent, page, {
-        sectionOverrideCSS: result.sectionOverrideCSS,
-      })
+      let html = result.html
 
       // Build-specific: theme CSS, __SITE_CONTENT__, icon cache.
       // scopeRoutes mirrors the runtime data cascade (page → page.parent → site)

package/src/site/data-fetcher.js

@@ -429,12 +429,10 @@ export function parseFetchConfig(fetch) {
       // ⭐ **`as` is the BINDING KEY** — the `content.data.<key>` a component
       // reads — defaulting 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
-      // content authored before the rename keeps working; it is never emitted.
-      // ⭐ `fetch.schema` here is an AUTHOR's older spelling in a content file —
-      // the same boundary normalization as the source-shape branch below, not
-      // the internal alias (removed 2026-09-02). One name travels inside.
-      as: fetch.as || fetch.schema || fetch.query,
+      // `queries` declaration. ⛔ **The old spelling is NOT read here, by
+      // ruling (2026-09-03): one name, no alias.** A fetch authored as
+      // `schema: posts` binds to nothing and is re-authored, not translated.
+      as: fetch.as || fetch.query,
       prerender: fetch.prerender ?? true,
       merge: fetch.merge ?? false,
       transform: fetch.transform,
@@ -455,7 +453,6 @@ export function parseFetchConfig(fetch) {
     path,
     url,
     as,
-    schema,
     prerender = url ? false : true,
     merge = false,
     transform,
@@ -477,12 +474,10 @@ export function parseFetchConfig(fetch) {
   return {
     path,
     url,
-    // ⭐ **The one place `schema` is still read, and it is a BOUNDARY
-    // normalization — not the internal alias.** An author may have written
-    // `fetch: { schema: person }` before the 2026-09-02 rename; that is content
-    // on someone's disk, not a field our own packages pass to each other.
-    // Translating it here means one name — `as` — everywhere inside.
-    as: as ?? schema ?? inferSchemaFromPath(path || url),
+    // ⛔ `schema` is NOT read here — by ruling (2026-09-03), the retired
+    // spelling has no alias anywhere, authored content included. A fetch that
+    // still says `schema:` gets the inferred key and is re-authored to `as:`.
+    as: as ?? inferSchemaFromPath(path || url),
     prerender,
     merge,
     transform,