@uniweb/runtime 1.2.10 → 1.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/runtime",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "Minimal runtime for loading Uniweb foundations",
   "type": "module",
   "exports": {
@@ -36,15 +36,15 @@
     "node": ">=22.12"
   },
   "dependencies": {
-    "@uniweb/theming": "~1.2.1",
-    "@uniweb/core": "~1.4.11"
+    "@uniweb/core": "~1.4.12",
+    "@uniweb/theming": "~1.2.1"
   },
   "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.10.10"
+    "@uniweb/build": "1.10.11"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/hooks/useLinkInterceptor.js

@@ -110,7 +110,8 @@ export function inAppLink(anchor) {
 
 /**
  * Whether a page of `website` can have something to fetch before it is shown: content not here
- * yet, on a site whose content is split, or data, which a site declaring queries reads.
+ * yet, on a site whose content is split, or data a page declares where it can be seen
+ * (`readsData`).
  */
 function hasPagesToFetch(website) {
   if (readsData(website)) return true

package/src/link-intent.js

@@ -2,9 +2,9 @@
  * Prefetch on intent: a link's page is fetched while the reader is about to follow it.
  *
  * Only a site with something to fetch before a page is shown loads this module
- * (`useLinkInterceptor`): split content not here yet, or data, which a site declaring queries
- * reads. A site with neither never downloads it, so the runtime every site carries pays only for
- * the decision.
+ * (`useLinkInterceptor`): split content not here yet, or data a page declares where it can be seen
+ * (`readsData`, `navigation.js`). A site with neither never downloads it, so the runtime every site
+ * carries pays only for the decision.
  *
  * A pointer resting on a link, or focus staying on one, for INTENT_DELAY fetches what the page
  * the link goes to will read: its split content, then its sections' data, whatever is not held

package/src/navigation.js

@@ -80,29 +80,47 @@ function isReady(page) {
 }
 
 /**
- * Whether the site declares a query. Data comes from a named query (`config.queries`), so a site
- * that declares none reads none, and its pages are not walked for it.
+ * Whether a fetch can be seen reaching `page` without building its sections: the site declares
+ * queries (`config.queries`), or a fetch sits on the page, its parent page or the site, or the page
+ * is parametric and asks for its own record. A section's own `fetch:` is read only once its block is
+ * built, so a page whose data is declared on its sections alone is not seen here.
+ *
+ * ⛔ `config.queries` alone is not the test. A hosted site's schema-less query is not projected
+ * there: its fetch carries the file's `path` (measured 2026-10-27 on a site's blog: no
+ * `config.queries`, the page's fetch `{ query, path, as }`). A gate on it skipped that blog's data.
+ *
+ * @param {Object} page
+ * @returns {boolean}
+ */
+function declaresData(page) {
+  const config = page.website?.config
+  const queries = config?.queries
+  if (queries && typeof queries === 'object' && Object.keys(queries).length > 0) return true
+  return !!(page.fetch || page.parent?.fetch || config?.fetch || page.dynamicContext)
+}
+
+/**
+ * Whether a page of `website` declares data where it can be seen without building sections (see
+ * `declaresData`): what decides whether prefetching on intent is worth its module.
  *
  * @param {Object|null|undefined} website
  * @returns {boolean}
  */
 export function readsData(website) {
-  const queries = website?.config?.queries
-  return !!queries && typeof queries === 'object' && Object.keys(queries).length > 0
+  return !!website?.pages?.some((page) => declaresData(page))
 }
 
 /**
  * Ask what `page`'s render will read and the cache does not hold: off a parametric page, the
  * page's own record, which names it; and each block's data, by the same call the renderer makes
- * after mount (`EntityStore.fetch`).
+ * after mount (`EntityStore.fetch`). It builds the page's blocks, which its render is about to do.
  *
  * @param {Object} page - its content here
  * @returns {Promise|undefined} undefined when nothing was asked
  */
 function dataOf(page) {
-  const website = page.website
-  const store = website?.entityStore
-  if (!store || !readsData(website)) return
+  const store = page.website?.entityStore
+  if (!store) return
   const asks = []
   if (page.dynamicContext) asks.push(store.fetchPageRecord(page))
   for (const block of blocksOf(page)) {
@@ -116,13 +134,19 @@ function dataOf(page) {
  * The wait for what `page`'s render reads and is not here yet: its split content, then, its
  * sections known, their data.
  *
+ * ⚖️ A navigation asks for the data of every page it goes to, since building the blocks is work its
+ * render does a moment later. A prefetch is a guess the reader may not follow, so it asks only where
+ * data can be seen reaching the page (`declaresData`), and leaves sections unbuilt elsewhere.
+ *
  * @param {Object|null} page
+ * @param {{ speculative?: boolean }} [options]
  * @returns {Promise|undefined} undefined when it is all here
  */
-function loadPage(page) {
+function loadPage(page, { speculative = false } = {}) {
   if (!page) return
-  if (!isReady(page)) return page.loadContent().then(() => dataOf(page))
-  return dataOf(page)
+  const data = () => (speculative && !declaresData(page) ? undefined : dataOf(page))
+  if (!isReady(page)) return page.loadContent().then(data)
+  return data()
 }
 
 /** `wait`, or the end of HOLD_TIMEOUT, whichever comes first. */
@@ -152,7 +176,7 @@ export function prefetchContent(route) {
  * @returns {Promise|undefined} undefined when it is all here
  */
 export function prefetchPage(route) {
-  return loadPage(pageAt(route))?.catch(() => {})
+  return loadPage(pageAt(route), { speculative: true })?.catch(() => {})
 }
 
 // The navigation the next swap belongs to. A later navigation supersedes one still waiting for