@uniweb/runtime 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/runtime",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Minimal runtime for loading Uniweb foundations",
   "type": "module",
   "exports": {
@@ -36,7 +36,7 @@
     "node": ">=22.12"
   },
   "dependencies": {
-    "@uniweb/core": "~1.4.6",
+    "@uniweb/core": "~1.4.7",
     "@uniweb/theming": "~1.2.1"
   },
   "devDependencies": {
@@ -44,7 +44,7 @@
     "esbuild": "^0.21.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.27.0 || ^0.28.0",
     "vite": "^7.3.1",
     "vitest": "^4.1.7",
-    "@uniweb/build": "1.9.0"
+    "@uniweb/build": "1.10.0"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/load-page-data.js

@@ -68,7 +68,8 @@ function blocksOf(page) {
  *   page asks for the site's and its parent's data and reading each address once is the difference
  *   between N reads and N×M. ⛔ Not for a host serving requests: there a page's data is asked
  *   fresh, and the default (a cache per call) is what does that. A shared cache changes nothing
- *   about what is ASKED or returned — every request is still recorded, hit or miss.
+ *   about what is ASKED or returned — every request is still recorded, hit or miss, and whether a
+ *   record is held whole already is answered from this call's own requests, never the cache's.
  * @returns {Promise<Array<{ config: Object, outcome: 'fetched'|'failed'|'skipped', data: *, meta?: Object, error?: string }>>}
  *   one entry per request the render will make, keyed downstream by `deriveCacheKey(config)`
  */
@@ -87,6 +88,11 @@ export async function loadPageData({ website, route, fetch, dev = false, locale
       '(`initPrerenderForLocale`) rather than asking this step for another language.'
     )
   }
+  // ⭐ This graph is the one `globalThis.uniweb` names while the step reads it, which it does here,
+  // before its first `await`: each block's component meta and the layout the page draws come
+  // through the global, and a host holding several graphs in one isolate has it naming the newest
+  // (`Website#makeCurrent`).
+  website.makeCurrent()
   const resolved = typeof route === 'string' ? resolvePage(website, route) : route
   // Nothing matched: a genuine 404, and the caller's to turn into one. Nothing to fetch.
   if (!resolved) return []
@@ -117,9 +123,16 @@ export async function loadPageData({ website, route, fetch, dev = false, locale
     if (!entries.has(key)) entries.set(key, entry)
   }
 
+  // ⭐ WHAT THIS CALL'S OWN REQUESTS ANSWERED — the record index the plan asks "held whole
+  // already?" before it asks for a record (R1). ⛔ Not the cache's: a shared one holds the records
+  // other pages fetched, and a record found there was never asked for, so never recorded, and the
+  // page carried nothing for it (2026-10-25). With a cache of this call's own, the two hold the
+  // same records.
+  const answered = new DataStore()
+
   const recording = {
     peek: (request, ctx) => dispatcher.peek(request, ctx),
-    peekRecord: (id) => dispatcher.peekRecord(id),
+    peekRecord: (id) => answered.getRecord(id),
     dispatch: async (request, ctx) => {
       if (prerender === 'author' && request?.prerender === false) {
         // The author deferred this one to the browser and the caller honours that. Present, so a
@@ -128,6 +141,9 @@ export async function loadPageData({ website, route, fetch, dev = false, locale
         return { data: null }
       }
       const result = await dispatcher.dispatch(request, ctx)
+      if (!result?.error && result?.data != null) {
+        answered.set(deriveCacheKey(request), result.meta ? { data: result.data, meta: result.meta } : { data: result.data })
+      }
       record(request, result?.error
         ? { config: request, outcome: 'failed', data: null, error: result.error }
         : { config: request, outcome: 'fetched', data: result?.data ?? null, ...(result?.meta ? { meta: result.meta } : {}) })

package/src/page-renderer.js

@@ -21,13 +21,15 @@
  *     cache headers are host layout, and a runtime that assembled them would be
  *     modelling a deployment it cannot see (the host drew this line itself,
  *     2026-09-03: a serve location is read from the payload, never constructed here).
- *   - **Init and hydration.** The two lanes differ REALLY here, not incidentally: a
- *     build initializes once per locale, hydrates its executor's answers up front and
- *     then runs the data step for each page over one cache for the whole run; an
- *     isolate initializes per locale and runs the step fresh for each request. Folding
- *     either in would fit one caller and lie to the other. `initPrerender` /
- *     `initPrerenderForLocale` / `loadPageData` / `hydrateDataStore` stay separate
- *     exports, and `prefetchAndHydrate` below is the isolate's two-step, not a general one.
+ *   - **Init and the data step.** The two lanes differ REALLY here, not incidentally: a
+ *     build initializes once per locale and runs the data step for each page over one
+ *     cache for the whole run; an isolate initializes per locale and runs the step fresh
+ *     for each request. Folding either in would fit one caller and lie to the other.
+ *     `initPrerender` / `initPrerenderForLocale` / `loadPageData` / `hydrateDataStore`
+ *     stay separate exports, and `prefetchAndHydrate` below is the isolate's two-step,
+ *     not a general one. ⭐ What both lanes DO share is the last step: the render reads
+ *     exactly the entries its page carries. That is `render`'s `fetchedData`, since
+ *     2026-10-25, and both lanes pass it.
  *   - **Anything build-only.** `injectBuildData` stays in the build lane; it is the
  *     other half of the head seam and has its own parity guard.
  */
@@ -65,6 +67,12 @@ export function createPageRenderer({ website, shell }) {
    *   Page, which the build lane already holds from its own loop.
    * @param {Object} [options]
    * @param {Object} [options.inject] - extra options forwarded to `injectPageContent`
+   * @param {Array<{config: Object, data: *, meta?: Object}>} [options.fetchedData] - the entries
+   *   the page carries: the `content.fetchedData` its HTML embeds, which the browser boots with.
+   *   ⭐ Given, the render reads exactly these. The Website forgets what it held, answers and the
+   *   parametric pages made from them (`Website#forgetData`), and files these, all in this
+   *   synchronous call, so a Website reused across requests renders each against its own and
+   *   no other request runs in between. Absent, the render reads whatever the store holds.
    * @returns {{ outcome: 'rendered'|'notFound'|'failed', html: string|null,
    *   page: Object|null, error: {type: string, message: string}|null }}
    *   `notFound` means the URL names nothing, and `html` says whether there is a page to
@@ -75,7 +83,24 @@ export function createPageRenderer({ website, shell }) {
    *   - `page` set, `html: null`, `error` set — that not-found state broke while rendering.
    *     Send your own not-found page; `error` says what broke.
    */
-  function render(target, { inject = {} } = {}) {
+  function render(target, { inject = {}, fetchedData } = {}) {
+    if (fetchedData !== undefined && !Array.isArray(fetchedData)) {
+      throw new Error('createPageRenderer: `fetchedData` must be the array of entries the page carries')
+    }
+    // ⭐ FIRST, THIS GRAPH IS THE ONE `globalThis.uniweb` NAMES. A block's component, the props
+    // pipeline and kit in the foundation reach the site through the global, and every graph built
+    // since this one was points it elsewhere — a host holds several in one isolate. The render is
+    // synchronous, so the value set here is the one it reads throughout (`Website#makeCurrent`).
+    website.makeCurrent()
+    // ⭐ BEFORE THE ROUTE IS RESOLVED: a parametric page is made from the store when it is first
+    // resolved, so resolving first would make it from what an earlier request left there.
+    // ⛔ Until 2026-10-25 a host that reused one Website hydrated each request's answers on top of
+    // every earlier request's, and a section that reads the store itself (kit's `useFetched`)
+    // could render answers its page did not carry, so the browser's first render differed.
+    if (fetchedData !== undefined) {
+      website.forgetData()
+      hydrateDataStore(website, fetchedData)
+    }
     const resolved = typeof target === 'string' ? resolvePage(website, target) : target
 
     // ⛔ Not an error: nothing matched, which is a genuine 404 and the caller's to

package/src/ssr-renderer.js

@@ -445,10 +445,16 @@ export async function prefetchIcons(siteContent, uniweb, onProgress = () => {})
       const url = iconUrl(family, name, cdnBase)
       const response = await fetch(url)
       if (!response.ok) throw new Error(`HTTP ${response.status}`)
-      const svg = await response.text()
-      uniweb.iconCache.set(`${family}:${name}`, svg)
+      return [`${family}:${name}`, await response.text()]
     })
   )
+  // ⭐ Cached in the order the build names the icons (`icons.used`, sorted), never the order their
+  // fetches settle in: the cache is written into every page (`_iconCache`, `__ICON_CACHE__`), so
+  // in arrival order two builds of one site wrote different pages. ⛔ Until 2026-10-25 each icon
+  // was cached as it arrived (measured: three builds of one site, three orders).
+  for (const result of results) {
+    if (result.status === 'fulfilled') uniweb.iconCache.set(...result.value)
+  }
 
   const succeeded = results.filter(r => r.status === 'fulfilled').length
   const failedRefs = icons.filter((_, i) => results[i].status === 'rejected')