@uniweb/kit 0.13.5 → 0.13.6

package/package.json

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

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()