@uniweb/runtime 1.2.2 → 1.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/runtime",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Minimal runtime for loading Uniweb foundations",
   "type": "module",
   "exports": {
@@ -36,15 +36,16 @@
     "node": ">=22.12"
   },
   "dependencies": {
-    "@uniweb/core": "~1.4.6",
-    "@uniweb/theming": "~1.2.1"
+    "@uniweb/core": "~1.4.8",
+    "@uniweb/theming": "~1.2.1",
+    "@uniweb/projections": "~1.2.2"
   },
   "devDependencies": {
     "@vitejs/plugin-react": "^4.5.2",
     "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.5"
   },
   "peerDependencies": {
     "react": "^19.0.0",
@@ -54,6 +55,7 @@
   "uniweb": {
     "bundledDeps": [
       "@uniweb/core",
+      "@uniweb/projections",
       "@uniweb/theming"
     ]
   },

package/src/components/PageRenderer.jsx

@@ -11,6 +11,7 @@ import { useLocation, useNavigate } from 'react-router-dom'
 import BlockRenderer from './BlockRenderer.jsx'
 import Layout from './Layout.jsx'
 import { useHeadMeta } from '../hooks/useHeadMeta.js'
+import { pageHeadMeta } from '../head-meta.js'
 import { useSectionViews } from '../hooks/useSectionViews.js'
 import { buildSectionOverrides } from '@uniweb/theming'
 import { carryQuery } from '@uniweb/core/resolve-route'
@@ -182,7 +183,7 @@ export default function PageRenderer() {
   }
 
   // Head metadata — compute for all cases (redirect pages get a fallback)
-  const headMeta = page?.getHeadMeta?.() || {
+  const headMeta = (typeof page?.getHeadMeta === 'function' && pageHeadMeta(page)) || {
     title: isNotFound ? 'Page Not Found' : (page?.title || 'Website'),
     description: page?.description || ''
   }

package/src/head-meta.js

@@ -0,0 +1,38 @@
+/**
+ * A page's head metadata, as both of its writers state it: the prerender (`injectPageContent`)
+ * and the browser (`useHeadMeta`).
+ *
+ * ⭐ `Page#getHeadMeta`'s, plus the address of the page's markdown (`markdown`), which the head
+ * links with `<link rel="alternate" type="text/markdown">` so an agent that lands on the HTML finds
+ * the document. The address is the one the site index gives the page, for the pages a markdown
+ * file is written for (`pageMarkdownUrls`, `@uniweb/projections`). It is added here rather than
+ * in core because core cannot depend on the package whose rules decide it.
+ */
+
+import { pageMarkdownUrls } from '@uniweb/projections/markdown-urls'
+
+// A site's markdown addresses, worked out once for its content. `rebuild({ content })` gives the
+// Website a new `pages` array, so that array is the key and a rebuilt site is worked out again.
+const urlsOfPages = new WeakMap()
+
+/**
+ * @param {Object} page - a Page
+ * @returns {Object} `page.getHeadMeta()`, and `markdown`: the URL of the page's markdown, or null —
+ *   for a page the index leaves out and the not-found page, and for a record's page made on
+ *   request (`uniweb dev`, a host), which is not among the content's pages. A static build's
+ *   record pages are: its prerender writes them into the content each page boots with.
+ */
+export function pageHeadMeta(page) {
+  return { ...page.getHeadMeta(), markdown: markdownUrlOf(page) }
+}
+
+function markdownUrlOf(page) {
+  const website = page?.website
+  if (!website) return null
+  let urls = urlsOfPages.get(website.pages)
+  if (!urls) {
+    urls = pageMarkdownUrls({ pages: website.getContentPages(), config: website.config })
+    urlsOfPages.set(website.pages, urls)
+  }
+  return urls.get(page.route) ?? null
+}

package/src/hooks/useHeadMeta.js

@@ -5,7 +5,7 @@
  * Updates meta tags when page changes in SPA navigation.
  *
  * ⭐ The browser twin of `injectPageContent`'s head tags, from the same source
- * (`Page#getHeadMeta`), so a crawler that runs the page's script reads what one that
+ * (`pageHeadMeta`), so a crawler that runs the page's script reads what one that
  * does not read. These tags are the framework's: each is set when the page has a value
  * and removed when it has none — as it must be, or a tag of the page before survives a
  * navigation. ⛔ Until 2026-10-25 this removed the canonical of every page that did not
@@ -116,6 +116,20 @@ function setAlternates(alternates) {
   }
 }
 
+/**
+ * The link to the page's markdown, replacing whatever the document carried
+ * @param {string|null} href
+ */
+function setMarkdownLink(href) {
+  for (const link of document.querySelectorAll('link[rel="alternate"][type="text/markdown"]')) link.remove()
+  if (!href) return
+  const link = document.createElement('link')
+  link.setAttribute('rel', 'alternate')
+  link.setAttribute('type', 'text/markdown')
+  link.setAttribute('href', href)
+  document.head.appendChild(link)
+}
+
 /**
  * useHeadMeta hook
  *
@@ -189,6 +203,7 @@ export function useHeadMeta(meta, options = {}) {
     }
 
     setAlternates(meta.alternates)
+    setMarkdownLink(meta.markdown || null)
 
     // Cleanup function - reset to defaults on unmount
     return () => {
@@ -209,6 +224,7 @@ export function useHeadMeta(meta, options = {}) {
     meta?.og?.siteName,
     meta?.twitter?.site,
     JSON.stringify(meta?.alternates || []),
+    meta?.markdown,
     siteName
   ])
 }

package/src/load-page-data.js

@@ -88,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 []

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

@@ -37,6 +37,7 @@ import { layoutStickiness, sectionStickyProps, sectionScrollMargin, zoneProps }
 import { DefaultLayout } from './default-layout.js'
 import { renderAppearanceBootScript } from './appearance.js'
 import { documentTitle } from './document-title.js'
+import { pageHeadMeta } from './head-meta.js'
 import { escapeHtml } from '@uniweb/core/page-shell'
 
 // Re-export L2 helpers so the public `@uniweb/runtime/ssr` surface
@@ -445,10 +446,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')
@@ -578,7 +585,8 @@ export { escapeHtml }
  * Common operations shared by both build and cloud:
  * - Replace #root div with rendered HTML
  * - Update page title
- * - Write the page's head tags — description, canonical, hreflang, Open Graph (`writeHeadMeta`)
+ * - Write the page's head tags — description, canonical, hreflang, Open Graph, the link to its
+ *   markdown (`writeHeadMeta`)
  * - Inject section override CSS
  * - Inject the pre-paint appearance script
  *
@@ -670,9 +678,10 @@ export function injectPageContent(html, renderedContent, page, options = {}) {
     )
   }
 
-  // ⭐ THE PAGE'S HEAD TAGS — description, canonical, hreflang, Open Graph, Twitter — from the
-  // page's own head metadata (`Page#getHeadMeta`, which the browser writes the same tags from in
-  // `useHeadMeta`), so crawlers and social unfurlers, which run no script, read the page's own.
+  // ⭐ THE PAGE'S HEAD TAGS — description, canonical, hreflang, Open Graph, Twitter, the link to its
+  // markdown — from the page's own head metadata (`pageHeadMeta`, which the browser writes the same
+  // tags from in `useHeadMeta`), so crawlers, social unfurlers and agents, which run no script,
+  // read the page's own.
   // ⛔ Until 2026-10-25 these were APPENDED, after the static build had written the HOME page's
   // into the one shell every page is rendered into: each page named the home page its canonical
   // and carried two og:title and two og:url, the home page's first.
@@ -692,8 +701,8 @@ export function injectPageContent(html, renderedContent, page, options = {}) {
  * @returns {string}
  */
 function writeHeadMeta(html, page) {
-  // A Page states its own (`getHeadMeta`); plain page data, which callers may hand in, its fields.
-  const meta = typeof page?.getHeadMeta === 'function' ? page.getHeadMeta() : { description: page?.description || null }
+  // A Page states its own (`pageHeadMeta`); plain page data, which callers may hand in, its fields.
+  const meta = typeof page?.getHeadMeta === 'function' ? pageHeadMeta(page) : { description: page?.description || null }
   const end = html.indexOf('</head>')
   if (!meta || end === -1) return html
   const og = meta.og || {}
@@ -727,6 +736,8 @@ function writeHeadMeta(html, page) {
   for (const { hreflang, url } of meta.alternates || []) {
     written.push(`<link rel="alternate" hreflang="${escapeHtml(hreflang)}" href="${escapeHtml(url)}">`)
   }
+  head = head.replace(/<link\b(?=[^>]*\brel=["']alternate["'])(?=[^>]*\btype=["']text\/markdown["'])[^>]*>\s*/gi, '')
+  if (meta.markdown) written.push(`<link rel="alternate" type="text/markdown" href="${escapeHtml(meta.markdown)}">`)
   return `${head}${written.join('\n')}\n${html.slice(end)}`
 }