@uniweb/runtime 0.15.0 → 0.17.0

package/src/prefetch.js

@@ -10,12 +10,12 @@
  * compute that itself: resolve the configs, issue the requests, unwrap the responses in the
  * shape the datastore expects — a copy of the runtime's logic, in another repo, drifting
  * (the records envelope went silently unread that way on 2026-09-02). [Diego, 2026-09-03]:
- * *the backend sets `config.records`; the fetch comes from the runtime.* The host now calls
+ * *the backend sets the records service; the fetch comes from the runtime.* The host now calls
  * this and carries no copy. Hosting agreed to exactly that shape the same day.
  *
  * ⛔ Contract with the host, deliberately small:
  *   - `content`  the render payload (`site-content.json` / `__DATA__`), config included —
- *                `config.records` and `config.base` are read from it.
+ *                `config.services` and `config.base` are read from it.
  *   - `route`    the page to prefetch for; a `[slug]` template resolves through the same
  *                matcher the SPA uses, so `/blog/post-1` finds `/blog/:slug`.
  *   - `fetch`    how to dispatch a request. The runtime composes the address; the host
@@ -46,7 +46,8 @@
  *                is a different cache decision (hosting, 2026-09-03).
  *
  * It resolves nothing the host owns and models no host route layout: every address is
- * `{base}/…` from the payload, or an endpoint the host itself published in `config.records`.
+ * `{base}/…` from the payload, or the records service the host itself
+ * published at `config.services.records`.
  */
 import { resolveFetchConfigs } from '@uniweb/core/fetch-config'
 import { deriveCacheKey } from '@uniweb/core/datastore'
@@ -117,7 +118,7 @@ export function resolvePageFetchConfigs(content, route, { locale = null } = {})
     locale,
     defaultLocale: resolveDefaultLocale(content?.config) ?? null,
     queries: content?.config?.queries ?? null,
-    records: content?.config?.records ?? null,
+    services: content?.config?.services ?? null,
     variables: binding?.variables ?? null,
   }
   const out = new Map()
@@ -162,7 +163,7 @@ export function resolvePageFetchConfigs(content, route, { locale = null } = {})
  * @param {Object[]} configs  resolved configs (from `resolvePageFetchConfigs` or the host's own
  *                             call to `resolveFetchConfigs`)
  * @param {Object} opts
- * @param {Object} opts.content  the payload — `config.base`, `config.records`
+ * @param {Object} opts.content  the payload — `config.base`, `config.services`
  * @param {Function} [opts.fetch]  the transport; defaults to the global `fetch`
  * @param {boolean} [opts.dev]
  * @returns {Promise<Array<{ config: Object, outcome: 'fetched'|'failed'|'skipped', data: any, error?: string }>>}
@@ -173,12 +174,11 @@ export async function executeFetchConfigs(configs, { content, fetch = null, dev
   }
   const fetcher = createDefaultFetcher({
     basePath: content?.config?.base || '',
-    records: content?.config?.records ?? null,
     dev,
     fetch,
   })
   const ctx = { website: null }
-  // Dispatched together, not one after another: a question door batches the
+  // Dispatched together, not one after another: the records service batches the
   // requests issued in one tick into one POST, and a page's configs are
   // independent of each other. Order is preserved in the result.
   return Promise.all((configs || []).filter(Boolean).map(async (config) => {

package/src/setup.js

@@ -246,11 +246,8 @@ function buildDefaultFetcher(content) {
   // transports (`fetcher.transports`) plus a transport's own binding config,
   // which a transport reads through ctx.website.config.fetcher.
   //
-  // The host's live-records stamp (`config.records`), when a backend set one: the fetcher
-  // reads its `envelope` for requests that resolved to that lane.
-  const records = content?.config?.records ?? null
   const dev = !!(import.meta.env && import.meta.env.DEV)
-  return createDefaultFetcher({ basePath, dev, records })
+  return createDefaultFetcher({ basePath, dev })
 }
 
 /**

package/src/ssr.js

@@ -58,7 +58,7 @@ export {
 
 // Server-side prefetch — the runtime executing a page's fetches for a host, so an isolate
 // receives `fetchedData` computed by our fetcher and the host carries no copy of it.
-// [Diego, 2026-09-03]: the backend sets config.records; the fetch comes from the runtime.
+// [Diego, 2026-09-03]: the backend sets the records service; the fetch comes from the runtime.
 export {
   findPageForRoute,
   resolvePageFetchConfigs,
@@ -72,6 +72,13 @@ export {
 // what it deliberately leaves to the host.
 export { createPageRenderer, prefetchAndHydrate } from './page-renderer.js'
 
+// The whole corpus, rather than one page — for a host that indexes a site or
+// derives something over every record its queries return. It asks through the
+// same client and the same composition a page render uses, which is the point:
+// an index that composed its own questions could offer a result whose page then
+// renders empty. The host supplies only the transport.
+export { collectSiteRecords } from './collect-records.js'
+
 // Appearance. injectPageContent() already emits this for every prerendered
 // page; exported for lanes that assemble a shell without a per-page render.
 export { renderAppearanceBootScript } from './appearance.js'