@uniweb/runtime 0.28.4 → 0.28.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/runtime",
-  "version": "0.28.4",
+  "version": "0.28.6",
   "description": "Minimal runtime for loading Uniweb foundations",
   "type": "module",
   "exports": {
@@ -36,7 +36,7 @@
     "node": ">=20.19"
   },
   "dependencies": {
-    "@uniweb/core": "^0.35.0",
+    "@uniweb/core": "^0.35.1",
     "@uniweb/theming": "^0.2.0"
   },
   "devDependencies": {
@@ -44,7 +44,7 @@
     "esbuild": "^0.21.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.27.0",
     "vite": "^7.3.1",
     "vitest": "^4.1.7",
-    "@uniweb/build": "0.73.3"
+    "@uniweb/build": "0.74.2"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/components/PageRenderer.jsx

@@ -122,12 +122,14 @@ export default function PageRenderer() {
   // Force re-render counter — incremented by DataStore listener below
   const [, forceUpdate] = useReducer((x) => x + 1, 0)
 
-  // Resolve page from current URL and sync website.activePage immediately.
-  // This must happen synchronously (not in an effect) so child components
-  // like Header see the correct activePage during the same render cycle.
+  // ⭐ WHAT THE URL NAMES — `Website#resolveRoute`, the one rule every lane calls
+  // (`@uniweb/core/resolve-route`): a page, a redirect, a page served from elsewhere, or
+  // nothing. Resolved synchronously (not in an effect) so child components like Header see the
+  // correct activePage during the same render cycle.
   const navigate = useNavigate()
 
-  let page = website?.getPage(location.pathname)
+  const resolution = website?.resolveRoute?.(location.pathname) ?? null
+  let page = resolution && resolution.kind !== 'notFound' ? resolution.page : null
   if (page && website) website.setActivePage(location.pathname)
 
   // ─── Content loading (split page content) ───
@@ -155,32 +157,16 @@ export default function PageRenderer() {
 
   // ─── Compute navigation targets (before hooks, no early returns) ───
 
-  // Explicit redirect: in page.yml
-  const redirectTarget = page?.redirect || null
-
-  // Auto-redirect for content-less pages (structural containers).
-  // Folders with page.yml but no markdown keep their route in the hierarchy;
-  // when visited directly, redirect to the first descendant with content.
-  //
-  // The DECISION stays canonical — `getNavigableRoute()` and `page.route` are
-  // both canonical, and comparing a localized URL against a canonical route
-  // would make a folder-with-index redirect to itself forever.
-  const navigableRoute = page && !page.redirect && !page.hasContent()
-    ? page.getNavigableRoute()
-    : null
-  const shouldAutoRedirect = !!(navigableRoute && navigableRoute !== page?.route)
-
-  // The DESTINATION is localized. `getNavigableRoute()` returns a canonical
-  // route, so navigating to it raw dropped both the slug translation and the
-  // `/<locale>` prefix: visiting `/fr/Guide-de-démarrage-rapide` landed on
-  // `/Quick-Start-Guide/From-Idea-to-Website` and served the page in ENGLISH.
-  // getLocaleUrl() is the same helper the language switcher uses.
-  const autoRedirectRoute = shouldAutoRedirect
-    ? website?.getLocaleUrl?.(website.activeLocale, navigableRoute) || navigableRoute
-    : null
+  // The redirect the URL names, as the resolver gives it: an author's `redirect:` as written; a
+  // page with no content to its first descendant with content, as THIS locale shows it (the
+  // decision canonical, the destination localized — `localeUrl`, the language switcher's rule);
+  // or the locale served unprefixed, asked for with its prefix, to the path without it.
+  // ⛔ This component worked the first two out for itself until 2026-09-30, and the static build
+  // and every host each had a copy.
+  const redirectLocation = resolution?.kind === 'redirect' ? resolution.location : null
 
   // If no page found, try the 404 page (do NOT fall back to activePage/homepage)
-  const isNotFound = !page && !redirectTarget
+  const isNotFound = !page && !redirectLocation
   if (isNotFound) {
     page = website?.getNotFoundPage?.() || null
   }
@@ -194,18 +180,14 @@ export default function PageRenderer() {
   // ─── All hooks called unconditionally (React rules of hooks) ───
 
   useEffect(() => {
-    if (!redirectTarget) return
-    if (redirectTarget.startsWith('http')) {
-      window.location.replace(redirectTarget)
+    if (!redirectLocation) return
+    // A URL with a scheme leaves the app — another site, or a locale's own domain.
+    if (/^[a-z][a-z0-9+.-]*:/i.test(redirectLocation)) {
+      window.location.replace(redirectLocation)
     } else {
-      navigate(redirectTarget, { replace: true })
+      navigate(redirectLocation, { replace: true })
     }
-  }, [redirectTarget, navigate])
-
-  useEffect(() => {
-    if (!shouldAutoRedirect) return
-    navigate(autoRedirectRoute, { replace: true })
-  }, [shouldAutoRedirect, autoRedirectRoute, navigate])
+  }, [redirectLocation, navigate])
 
   useHeadMeta(headMeta, { siteName })
 
@@ -221,13 +203,12 @@ export default function PageRenderer() {
 
   // ─── Early returns (after all hooks) ───
 
-  if (redirectTarget) return null
-  if (shouldAutoRedirect) return null
+  if (redirectLocation) return null
 
   // Rewrite pages are served by an external site — the host handles routing.
   // In SPA mode this shouldn't be reached (host proxies before JS loads),
   // but if it is (e.g., dev mode), do a full page reload to let the host handle it.
-  if (page?.rewrite) {
+  if (resolution?.kind === 'rewrite') {
     window.location.reload()
     return null
   }

package/src/default-fetcher.js

@@ -252,7 +252,9 @@ export function createDefaultFetcher({ basePath = '', dev = false, fetch: fetchI
  * Anything the service does not answer (a retired operator) is sent as written and
  * answered there: never approximated.
  */
-function toQuestion(request) {
+// Exported so the question a parametric page's record is asked with can be generated as test
+// vectors: it is this body, and nothing else composes one.
+export function toQuestion(request) {
   const q = { schema: request.schema }
   const where = request.where && typeof request.where === 'object' ? request.where : null
   // ⭐ `scope` crosses as authored. ⛔ A top-level `where.path.under` was respelled

package/src/isolate-api.js

@@ -106,6 +106,12 @@ export const ISOLATE_API = Object.freeze({
   prefetchAndHydrate: '0.14.2',
   // the whole corpus, for a host that indexes rather than renders
   collectSiteRecords: '0.17.0',
+  // what a URL names — a page, a redirect, a page served from elsewhere, or nothing
+  resolveRoute: UNRELEASED,
+  routeIndex: UNRELEASED,
+  localeOfPath: UNRELEASED,
+  localeUrl: UNRELEASED,
+  RESOLUTION_STATUS: UNRELEASED,
 })
 
 /**

package/src/page-renderer.js

@@ -65,6 +65,13 @@ export function createPageRenderer({ website, shell }) {
    * @param {Object} [options.inject] - extra options forwarded to `injectPageContent`
    * @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
+   *   send for it:
+   *   - `page: null`, `html: null` — no route matched. Send your own not-found page.
+   *   - `page` set, `html` set — the page's record does not exist, and `html` is the page
+   *     rendered in its own not-found state. Send it, with your not-found status.
+   *   - `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 = {} } = {}) {
     const resolved = typeof target === 'string' ? resolvePage(website, target) : target
@@ -86,6 +93,16 @@ export function createPageRenderer({ website, shell }) {
     // you", not throw.
     const page = typeof resolved.getRenderableSelf === 'function' ? resolved.getRenderableSelf() : resolved
 
+    // ⭐ A PAGE CAN RESOLVE AND STILL NAME NOTHING: a parametric page whose record does
+    // not exist. Core marks it `notFound` only when the data answered definitively
+    // (`Website#_createDynamicPage`), never on a failed or missing fetch. It renders the
+    // page's own not-found state — a record miss is not a route miss — and the outcome
+    // says `notFound` all the same, so a caller keying its status on the outcome sends a
+    // not-found response without reading anything new. Known before rendering, so it
+    // holds even when that render breaks. ⛔ Until 2026-09-30 this was `rendered`, and a
+    // host that answered by the outcome sent 200 for a URL naming no record.
+    const missing = page?.notFound === true
+
     let result
     try {
       result = renderPage(page, website)
@@ -93,10 +110,10 @@ export function createPageRenderer({ website, shell }) {
       // `renderPage` handles its own errors, but a foundation can throw from
       // module scope in ways it does not catch. Classify rather than propagate,
       // so one page cannot take down a build loop or an isolate's request.
-      return { outcome: 'failed', html: null, page, error: classifyRenderError(err) }
+      return { outcome: missing ? 'notFound' : 'failed', html: null, page, error: classifyRenderError(err) }
     }
 
-    if (result.error) return { outcome: 'failed', html: null, page, error: result.error }
+    if (result.error) return { outcome: missing ? 'notFound' : 'failed', html: null, page, error: result.error }
 
     // ⛔ `sectionOverrideCSS` LAST, so a caller's `inject` cannot displace it. It is
     // computed by `renderPage` for this page — theme pinning and component vars —
@@ -108,7 +125,7 @@ export function createPageRenderer({ website, shell }) {
       ...inject,
       sectionOverrideCSS: result.sectionOverrideCSS,
     })
-    return { outcome: 'rendered', html, page, error: null }
+    return { outcome: missing ? 'notFound' : 'rendered', html, page, error: null }
   }
 
   return { website, render }

package/src/ssr.js

@@ -63,10 +63,18 @@ export {
 // hydration.
 export { loadPageData } from './load-page-data.js'
 
-// Which page a route names — the rule, not a copy of it (`@uniweb/core/route-match`). A host
-// resolving a route before it asks us anything imports this rather than comparing strings: the
-// SPA normalizes a trailing slash, and a copy that did not made `/about/` prefetch nothing and
-// then render fine (2026-09-12).
+// ⭐ WHAT A URL NAMES — a page, a redirect, a page served from elsewhere, or nothing: the rule the
+// SPA and the static build call (`@uniweb/core/resolve-route`). A host asks it BEFORE it fetches:
+// a redirect needs no data and a URL naming nothing needs no render. It reads one locale's content;
+// `localeOfPath` says which locale a path names, so which content to read. `status` is what a host
+// that sends one sends. ⛔ Each host kept its own copy of the redirect and locale rules until
+// 2026-09-30, and the copies disagreed.
+export { resolveRoute, routeIndex, localeOfPath, localeUrl, RESOLUTION_STATUS } from '@uniweb/core/resolve-route'
+
+// Which page a route names, by its exact route and then the parametric patterns
+// (`@uniweb/core/route-match`). ⚠️ The subset of `resolveRoute`: no locale prefix, no translated
+// route, no index page — for a canonical, unprefixed route only. A copy that compared strings made
+// `/about/` prefetch nothing and then render fine (2026-09-12).
 // ⛔ `prefetchPageData`, `resolvePageFetchConfigs` and `executeFetchConfigs` are GONE (2026-09-20).
 // They worked from the payload alone, which cannot say which keys a component declares, which
 // layout a page draws, or which transport a key is routed to — four measured cases wrong