@uniweb/kit 0.13.5 → 0.13.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/kit",
-  "version": "0.13.5",
+  "version": "0.13.7",
   "description": "Standard component library for Uniweb foundations",
   "type": "module",
   "exports": {
@@ -44,7 +44,7 @@
     "shiki": "^3.0.0",
     "tailwind-merge": "^3.6.0",
     "temml": "^0.13.2",
-    "@uniweb/core": "^0.12.0",
+    "@uniweb/core": "^0.13.0",
     "@uniweb/semantic-parser": "^1.3.1",
     "@uniweb/scene": "^0.1.3"
   },

package/src/hooks/useEntityDetail.js

@@ -44,7 +44,7 @@
  * }
  */
 
-import { getUniweb, recordDataUrl } from '@uniweb/core'
+import { getUniweb, resolveFetchConfigs, buildDetailConfig } from '@uniweb/core'
 import { useFetched } from './useFetched.js'
 
 /**
@@ -60,46 +60,68 @@ import { useFetched } from './useFetched.js'
 export function useEntityDetail(record, options = {}) {
   const collection = options?.collection
   const request = buildDetailRequest(record, collection)
-  return useFetched(request)
+  const result = useFetched(request)
+
+  // No separate detail source for this collection — nothing was stripped from
+  // the cascade, so the record the caller already holds IS the whole record.
+  // Returning it beats both alternatives: `null` makes every caller null-check
+  // a case that cannot fail, and requesting the per-record file anyway is a
+  // guaranteed 404, because that file is only written for a `deferred:`
+  // collection. `useFetched` is still called above — unconditionally, as the
+  // rules of hooks require — and simply skips on a null request.
+  if (record && collection && !request) {
+    return { data: record, error: null, loading: false }
+  }
+  return result
 }
 
 /**
  * Build the fetch request for one record's full payload.
  *
- * Exported for tests only — not re-exported from the package index. The
- * static-file branch has to resolve to the same URL the build writes and the
- * same URL core's dynamic-route auto-detail injects; a test can only assert
- * that if it can call this without a React tree.
+ * ⛔ THIS MUST NOT DECIDE THE ADDRESS ITSELF, and it used to. It read
+ * `config.collections[name].detailUrl` directly and otherwise composed
+ * `/data/<name>/<slug>.json` by hand, which was wrong three ways: it 404'd on
+ * any collection without `deferred:` (that file is only written for one), it
+ * could not see a host's live record lane at all, and its hand-rolled `{slug}`
+ * replace ignored a route whose param is named anything else.
+ *
+ * Every one of those is already solved once, in the resolution the runtime and
+ * the prerenderer share. So this hands the collection to that resolution and
+ * asks it the same question they ask: `resolveFetchConfigs` decides where the
+ * collection lives (a host's lane, or the compiled artifact) and what its
+ * per-record source is, then `buildDetailConfig` turns that plus a param into a
+ * request. A fourth answer computed here is a fourth thing to drift.
+ *
+ * Returns null when the collection has no separate detail source — the common
+ * case, and not a failure. The caller's record is already whole.
+ *
+ * Exported for tests only — not re-exported from the package index.
  *
  * @param {Object|null} record
  * @param {string} collection
- * @returns {{path?: string, url?: string, schema: string}|null}
+ * @returns {{path?: string, url?: string, endpoint?: string, schema: string}|null}
  */
 export function buildDetailRequest(record, collection) {
   const slug = record?.slug
   if (!slug || !collection) return null
 
-  // Look up the collection's per-record source pattern. Authors with
-  // API-backed collections declare `detailUrl:` in site.yml; markdown
-  // collections leave it null and use the static-file default.
   const website = getUniweb()?.activeWebsite
-  const collConfig = website?.config?.collections?.[collection]
-  const detailUrl = (collConfig && typeof collConfig.detailUrl === 'string')
-    ? collConfig.detailUrl
-    : null
+  const config = website?.config
 
-  if (detailUrl) {
-    // Substitute {slug} into the author-declared pattern and use url:
-    // (the source is remote).
-    const url = detailUrl.replace(/\{slug\}/g, encodeURIComponent(slug))
-    return { url, schema: collection }
-  }
+  // One synthetic source, resolved by the shared rule — same inputs the
+  // EntityStore passes, so the hook cannot disagree with the page it sits on.
+  const resolved = resolveFetchConfigs([{ collection, schema: collection }], {
+    collections: config?.collections ?? null,
+    records: config?.records ?? null,
+    locale: website?.getActiveLocale?.() ?? null,
+    defaultLocale: website?.getDefaultLocale?.() ?? null,
+  }).get(collection)
+
+  if (!resolved) return null
 
-  // Static-file default — the build emitted per-record JSON files. Shares
-  // `recordDataUrl` with the build that writes them and with core's
-  // dynamic-route auto-detail injection, which is the other half of this
-  // same feature: the three must resolve one record to one URL.
-  return { path: recordDataUrl(collection, slug), schema: collection }
+  // `slug` is this hook's contract with its caller (the record must carry one).
+  // The `{param}` alias means a host-written record pattern resolves too.
+  return buildDetailConfig(resolved, { paramName: 'slug', paramValue: slug })
 }
 
 export default useEntityDetail

package/src/search/client.js

@@ -142,6 +142,37 @@ export function createSearchClient(website, options = {}) {
   // host serves none.
   const authoredProvider = website?.config?.search?.provider
 
+  // ⛔ …BUT AN AUTHORED `index` IS NOT A CHOICE, IT IS THE DEFAULT SPELLED OUT.
+  // `getSearchConfig()` fills `provider: 'index'` when the author said nothing,
+  // and `docs/authoring/search.md` shows it in its options block labelled
+  // "default" — so a site that copied that block to set `include:` or
+  // `exclude:` carries it without having decided anything.
+  //
+  // Treating it as a veto pinned exactly those sites to the local index. On a
+  // host-served site that index does not exist (the build stops emitting one on
+  // that lane), so an ENTITLED site — one whose host does offer search — drew a
+  // box, queried `search-index.json`, and got a 404. They had bought the
+  // feature and could not use it.
+  //
+  // ⇒ An authored `index` no longer outranks a host's offer. Any OTHER authored
+  // provider still does: `endpoint` and a foundation transport are real choices
+  // and the comment above still applies to them.
+  //
+  // ⚠️ This removes one thing an author could previously express — "use the
+  // local index even though my host offers search". On a host-served lane that
+  // preference resolves to a 404 either way, and on a static host `source` is
+  // never 'host' so this branch cannot fire and the local index is untouched.
+  //
+  // ⛔ REACHES NEW AND REBUILT FOUNDATIONS ONLY. A foundation bundles its own
+  // frozen copy of this file, so an already-published one keeps the old
+  // precedence. Unlike the host-decline check — which lives in `@uniweb/core`
+  // precisely so the runtime carries it to every foundation regardless of age —
+  // provider selection is kit's, and frozen kit reads `website.config` directly.
+  // There is no honest core-side fix: it would mean rewriting authored config
+  // to steer a consumer's branch.
+  const authoredVeto =
+    authoredProvider && authoredProvider !== 'index' ? authoredProvider : null
+
   // ⛔ THE HOST ANSWERED AND DECLINED. `resolveService` returns
   // `{ url: null, source: 'host' }` when a host declares the service NAME
   // while offering no address — the decline shape `@uniweb/core/services`
@@ -173,7 +204,7 @@ export function createSearchClient(website, options = {}) {
 
   const declared =
     providerOverride ||
-    authoredProvider ||
+    authoredVeto ||
     (service.source === 'host' ? 'endpoint' : 'index')
 
   // One in-flight resolution shared by every caller.

package/src/search/providers/endpoint-provider.js

@@ -168,21 +168,32 @@ export function createEndpointProvider(website, options = {}) {
         // more than "403". `isEnabled()` is what a foundation asks, and it is
         // false long before this line runs.
         //
-        // ⚠️ Ordering, if the local-index fallback in `client.js` is ever
-        // removed: that fallback is currently what stops this string
-        // propagating, so removing it would surface this message where nothing
-        // renders one today. Settle where a provider error may surface FIRST.
+        // ⛔ THE HOST'S SENTENCE GOES TO THE CONSOLE, NEVER INTO THE THROW.
+        //
+        // It used to become the Error's message, and `useSearch` exposes
+        // `error` — so a foundation rendering it would have shown a visitor a
+        // host-authored English sentence about someone's provisioning state.
+        // The only thing preventing that was `client.js`'s local-index
+        // fallback swallowing the throw, which is incidental: that fallback
+        // exists to DEGRADE, and removing it (reasonable — on a host-served
+        // lane there is no index to fall back to) would have surfaced the
+        // sentence as its first act.
+        //
+        // ⇒ Splitting the two registers removes the ordering hazard entirely
+        // rather than documenting it: whatever reaches `error` is now
+        // framework-authored and carries no host prose, so the fallback can be
+        // removed on its own merits whenever someone wants to.
         let declined
         try {
           declined = (await response.json())?.error
         } catch {
           /* not JSON — the status is all there is */
         }
-        throw new Error(
-          typeof declined === 'string' && declined.trim()
-            ? declined.trim()
-            : `Search endpoint returned ${response.status}`
-        )
+        if (typeof declined === 'string' && declined.trim()) {
+          // Developer register: a console reader needs more than a number.
+          console.warn(`[uniweb] search endpoint declined: ${declined.trim()}`)
+        }
+        throw new Error(`Search endpoint returned ${response.status}`)
       }
 
       const payload = await response.json()