@uniweb/build 0.16.10 → 0.16.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.16.10",
+  "version": "0.16.12",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -59,15 +59,15 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
-    "@uniweb/content-writer": "0.3.3",
+    "@uniweb/theming": "0.1.15",
     "@uniweb/projections": "0.2.5",
-    "@uniweb/theming": "0.1.15"
+    "@uniweb/content-writer": "0.3.3"
   },
   "optionalDependencies": {
     "@uniweb/content-reader": "1.2.2",
-    "@uniweb/runtime": "0.9.4",
-    "@uniweb/semantic-parser": "1.2.1",
-    "@uniweb/schemas": "0.2.5"
+    "@uniweb/schemas": "0.2.5",
+    "@uniweb/runtime": "0.9.5",
+    "@uniweb/semantic-parser": "1.2.1"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/site/build-site-data.js

@@ -27,10 +27,6 @@ import { processCollections, writeCollectionFiles } from './collection-processor
 import { processAssets, rewriteSiteContentPaths } from './asset-processor.js'
 import { processAdvancedAssets } from './advanced-processors.js'
 import {
-  generateSearchIndex,
-  generateCollectionIndex,
-  mergeSearchIndexes,
-  getSearchIndexFilename,
   renderSiteIndex,
   renderPageMarkdown,
   resolveAgentsConfig,
@@ -205,58 +201,26 @@ export async function buildSiteData({
   const contentPath = join(resolvedDistDir, 'site-content.json')
   await writeFile(contentPath, JSON.stringify(finalContent, null, 2))
 
-  // 5. Generate `_search/{locale}/pages.json` and per-collection indexes.
-  //    Gated by `features: [search]` in site.yml — consistent with the billing
-  //    model where features: is the single declaration of intent. The hosting
-  //    worker has its own entitlement gate (searchEnabled) that decides whether
-  //    to store these files, but no point generating them when the site hasn't
-  //    declared the feature at all.
-  const siteFeatures = finalContent.config?.features || []
-  if (Array.isArray(siteFeatures) && siteFeatures.includes('search')) {
-    const defaultLocale = resolveDefaultLocale(finalContent.config)
-    const searchDir = join(resolvedDistDir, '_search', defaultLocale)
-    await mkdir(searchDir, { recursive: true })
-
-    // pages.json — static pages + sections
-    const pagesIndex = generateSearchIndex(finalContent, {
-      locale: defaultLocale,
-      search: finalContent.config?.search,
-    })
-    const { version: _v, count: _c, ...pagesRest } = pagesIndex
-    await writeFile(join(searchDir, 'pages.json'), JSON.stringify({ type: 'pages', ...pagesRest }))
-
-    // Collection indexes — one per routed + search-configured collection
-    const collections = finalContent.config?.collections || {}
-    const collectionIndexes = []
-    for (const [collName, collConfig] of Object.entries(collections)) {
-      if (!collConfig.search?.enabled || !collConfig.route) continue
-      const cascadeFile = join(resolvedDistDir, DATA_DIR, `${collName}.json`)
-      if (!existsSync(cascadeFile)) continue
-      let collectionData
-      try {
-        collectionData = JSON.parse(await readFile(cascadeFile, 'utf8'))
-      } catch {
-        continue
-      }
-      const collIndex = generateCollectionIndex(collName, collConfig, collectionData, defaultLocale)
-      collectionIndexes.push(collIndex)
-      await writeFile(join(searchDir, `${collName}.json`), JSON.stringify(collIndex))
-    }
-
-    // The single-file form, for the BROWSER lane.
-    //
-    // The split files above serve a server that loads only the parts a query
-    // needs. Kit's client-side `index` provider needs all of it, and asks for
-    // `search-index.json` — so without this, a site published through this lane
-    // 404s on its own search index and degrades to no results. Emitting both
-    // from the same entries is one extra serialization and means the client
-    // works identically on every lane, with no host configuration describing
-    // where the index lives.
-    await writeFile(
-      join(resolvedDistDir, getSearchIndexFilename(defaultLocale, defaultLocale)),
-      JSON.stringify(mergeSearchIndexes(pagesIndex, collectionIndexes))
-    )
-  }
+  // 5. (removed 2026-08-01) This lane used to emit a search index — the split
+  //    `_search/{locale}/*.json` for a server, and `search-index.json` for the
+  //    browser — gated by `features: [search]`.
+  //
+  //    Both are gone because only ONE of the two publishers produced them. A
+  //    CLI deploy did; a CMS publish did not, so a site's search existed or
+  //    vanished depending on who published it last. That is the flicker rule,
+  //    and the fix is not to make the app produce them too — it is that a host
+  //    storing the content derives search from it, one input that exists
+  //    identically on both lanes.
+  //
+  //    The browser one was doubly dead: nothing ever uploaded it. `dist/` on
+  //    this lane reaches a backend only through the data ball and the media
+  //    refs, and the ball read `dist/data` and `dist/_search` — never the dist
+  //    root. So it was serialized on every publish and dropped.
+  //
+  //    ⚠️ The static index for hosts with NO backend is untouched and still
+  //    emitted by the bundle lane (`site/plugin.js` → `search-index.json`).
+  //    That is what GitHub Pages and every other static target serve, and the
+  //    framework has more targets than one backend.
 
   // 6. Agent projections — `llms.txt` and one `.md` per page.
   //

package/src/site/data-ball.js

@@ -3,17 +3,17 @@
  * collections partition by schema presence: a collection that resolves a data schema
  * syncs as folder entities; a SCHEMA-LESS collection has no entity model, so its built
  * `dist/data/<name>.json` (cascade + any `deferred:` per-record files) is delivered
- * statically. This bundles that schema-less subset of `dist/data/**` plus the whole
- * `dist/_search/**` index into one JSON doc the deploy uploads as a single
- * content-addressed asset; the backend unwraps it into the `/data/*` + `/_search/*`
- * bytes the gateway serves.
+ * statically. This bundles that schema-less subset of `dist/data/**` into one JSON doc
+ * the deploy uploads as a single content-addressed asset; the backend unwraps it into
+ * the `/data/*` bytes the gateway serves.
  *
- *   { data:   { "<relpath-under-data>":    <json> },   // schema-less collections only
- *     search: { "<relpath-under-_search>": <json> } }  // the whole (baked) index
+ *   { data: { "<relpath-under-data>": <json> } }   // schema-less collections only
  *
- * Search is NOT filtered: the index is baked over all content (the live/baked seam —
- * schema-backed lists are served live from entities, but their search entries are baked
- * here until the next deploy).
+ * **A search index used to ride here too, and deliberately no longer does** (2026-08-01).
+ * Only a CLI deploy produced one — a CMS publish produced none — so a site's search
+ * existed or vanished depending on who published it, which is the flicker rule exactly.
+ * A host that wants search derives it from the content it already stores. See the note
+ * at the removal point below, and `collab/context/site-derived-artifacts.md`.
  */
 
 import { existsSync } from 'node:fs'
@@ -54,8 +54,7 @@ function collectionOf(relPath) {
  * @param {string} distDir - the site's built dist/ directory
  * @param {string[]} [schemalessNames] - collection names with no data schema (from
  *        `emitSyncPackages(...).schemaless`); only these contribute `data`.
- * @returns {Promise<{ data: Object, search: Object }|null>} null when there is nothing
- *          to deliver (no schema-less data AND no search index).
+ * @returns {Promise<{ data: Object }|null>} null when there is nothing to deliver.
  */
 export async function assembleDataBall(distDir, schemalessNames = []) {
   const schemaless = new Set(schemalessNames)
@@ -64,8 +63,6 @@ export async function assembleDataBall(distDir, schemalessNames = []) {
   for (const [relPath, value] of Object.entries(allData)) {
     if (schemaless.has(collectionOf(relPath))) data[relPath] = value
   }
-  const search = await readJsonTree(join(distDir, '_search'))
-
   // Agent projections deliberately do NOT ride the ball.
   //
   // A backend that stores the site's content derives them itself at publish —
@@ -78,10 +75,41 @@ export async function assembleDataBall(distDir, schemalessNames = []) {
   // (An opt-in `projections` bucket lived here while the delivery contract was
   // open. It never shipped enabled, and the one-producer ruling closed the
   // question — removed rather than left as a flag nobody may turn on.)
+  //
+  // THE SEARCH INDEX IS ONE OF THOSE PROJECTIONS, and it rode this ball anyway
+  // — `const search = readJsonTree(dist/_search)` sat four lines above this
+  // comment, doing the exact thing the comment forbids. Removed 2026-08-01.
+  //
+  // What made it wrong is not symmetry, it is the flicker rule: a CLI deploy
+  // produced the index and a CMS publish produced none, so a site's search
+  // oscillated with whoever published it. Deriving it from stored content — one
+  // input that exists identically on both lanes — makes that unexpressible,
+  // which is a stronger guarantee than any producer agreement.
+  //
+  // The static index for hosts with no backend is UNCHANGED and still emitted:
+  // `search-index.json`, bundle lane, what GitHub Pages and every other static
+  // target serve. The framework has more targets than one backend, and that is
+  // the artifact for the rest of them.
 
-  if (Object.keys(data).length === 0 && Object.keys(search).length === 0) return null
+  if (Object.keys(data).length === 0) return null
 
-  return { data, search }
+  // The `search` key is gone too, and that was the SECOND step of a two-step
+  // retirement, not an afterthought.
+  //
+  // Step one shipped `search: {}` — content removed, key kept — because an
+  // absent field and an empty one are different shapes to a strict
+  // deserializer, and a missing required field fails exactly as loudly as an
+  // unknown one. (The producer half of this same contract broke pushes earlier
+  // the same day by emitting a key the consumer had not declared. Same failure,
+  // opposite direction.) Step two is this: the consumer retired the field on
+  // 2026-08-01 and said an older CLI still sending it deploys fine, so the key
+  // now has nowhere to land and dropping it is safe in both directions.
+  //
+  // Worth keeping as a shape: **announce, then remove** — the mirror of
+  // "declare, then emit". Neither half of a wire can be changed in one step by
+  // one side, and which side moves first is decided by which direction the
+  // strictness runs.
+  return { data }
 }
 
 // --- local media in the ball -------------------------------------------------
@@ -97,7 +125,7 @@ export async function assembleDataBall(distDir, schemalessNames = []) {
  * Site-root local asset refs anywhere in the ball (`/images/x.png`, `/collections/...`).
  * Built `dist/data` refs are already site-root (the collection processor copied
  * co-located assets to `public/collections/**`), so only `/`-prefixed refs are collected.
- * @param {{data:object,search:object}|null} ball
+ * @param {{data:object}|null} ball
  * @returns {string[]} deduped refs to upload
  */
 export function collectBallAssets(ball) {
@@ -118,9 +146,9 @@ export function collectBallAssets(ball) {
  * Rewrite the ball: replace every local ref the map covers with its serve URL. Pure —
  * returns a NEW ball (the input is reused elsewhere). A ref the map omits (upload
  * failed/skipped) is left untouched — never a broken URL.
- * @param {{data:object,search:object}|null} ball
+ * @param {{data:object}|null} ball
  * @param {Record<string,string>} map - ref → serve URL
- * @returns {{data:object,search:object}|null} a new ball, or the input when there's nothing to do
+ * @returns {{data:object}|null} a new ball, or the input when there's nothing to do
  */
 export function rewriteBallAssets(ball, map) {
   if (!ball || !map || Object.keys(map).length === 0) return ball