@uniweb/build 1.9.1 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -53,15 +53,15 @@
   "dependencies": {
     "@citestyle/bibtex": "^1.1.0",
     "esbuild": "^0.21.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.27.0 || ^0.28.0",
-    "js-yaml": "^4.1.0",
-    "sharp": "^0.35.3",
+    "js-yaml": "^4.3.2",
+    "sharp": "^0.35.5",
     "yaml": "^2.5.0",
-    "@uniweb/content-reader": "~1.5.6",
+    "@uniweb/content-reader": "~1.5.7",
+    "@uniweb/content-writer": "~1.3.1",
     "@uniweb/projections": "~1.2.0",
-    "@uniweb/content-writer": "~1.3.0",
+    "@uniweb/theming": "~1.2.1",
     "@uniweb/schemas": "~1.6.5",
-    "@uniweb/semantic-parser": "~1.13.0",
-    "@uniweb/theming": "~1.2.1"
+    "@uniweb/semantic-parser": "~1.13.0"
   },
   "optionalDependencies": {
     "@uniweb/runtime": "~1.2.2"

package/src/i18n/index.js

@@ -26,8 +26,8 @@ import {
   RECORD_LOCALES_DIR
 } from './records.js'
 import { resolveDefaultLocale } from '@uniweb/core'
-import { generateSearchIndex } from '@uniweb/projections'
-import { searchDeclaredOn } from '../site/search-declared.js'
+import { compiledData, recordProjections } from '../site/record-projections.js'
+import { projectionFiles } from '../site/projections.js'
 
 // Free-form translation support
 import {
@@ -346,21 +346,89 @@ function declaredLanguages(config, defaultLocale, locales) {
   return out
 }
 
+/**
+ * ⭐ EVERY LANGUAGE OF A SITE BUT ITS DEFAULT, IN THE ORDER ITS FILES NEED: its records, then its
+ * content, then — when `projections` asks — its search index, `llms.txt` and `.md` files, which are
+ * made from both (`../site/projections.js`). The default language's are the bundle's
+ * (`site/plugin.js`); this builds the rest.
+ *
+ * ⛔ Until 2026-10-25 a build ran content, then records — in two places, one per lane — and a
+ * language's search index was written inside the content step, from its pages alone, before its
+ * records were translated. So the French index of a site listed none of its record pages while the
+ * default one listed all of them, and no language but the default got an `llms.txt` or a `.md`
+ * (measured on a starter in three languages: 17 search entries against 20, and no `fr/llms.txt`).
+ *
+ * @param {string} siteRoot - Site root directory
+ * @param {Object} options
+ * @param {string[]} options.locales - the languages to build; the default is skipped
+ *   (`buildLocalizedContent`)
+ * @param {string} [options.localesDir='locales'] - where the translations are, from `siteRoot`
+ * @param {string} [options.outputDir] - the built site, `<siteRoot>/dist` by default
+ * @param {boolean} [options.projections=false] - write each language's projections. The bundle
+ *   lane's: a static host serves them. The link lane builds for a host, which derives its own.
+ * @returns {Promise<{ content: Object, records: Object, projections: Object }>} what each step
+ *   wrote, by language — `projections[locale]` the files (`projectionFiles`), each `fileName`
+ *   from `outputDir`
+ */
+export async function buildLocalizedSite(siteRoot, options = {}) {
+  const { localesDir = DEFAULTS.localesDir, outputDir = join(siteRoot, 'dist'), projections = false } = options
+
+  // The default language is the root tree, never a subdirectory — by the default the content step
+  // reads (`buildLocalizedContent`), so the records step writes no `dist/<default>/data/` either.
+  const source = JSON.parse(await readFile(join(outputDir, 'site-content.json'), 'utf-8'))
+  const defaultLocale = resolveDefaultLocale(source.config)
+  const locales = (options.locales || []).filter((locale) => locale !== defaultLocale)
+
+  // Records first: a language's projections list its record pages, and translating them reads
+  // the site's own files alone — never a translated page.
+  const records = await buildLocalizedRecords(siteRoot, {
+    locales,
+    outputDir,
+    recordLocalesDir: join(siteRoot, localesDir, RECORD_LOCALES_DIR),
+    localesDir: join(siteRoot, localesDir)
+  })
+  const content = await buildLocalizedContent(siteRoot, { localesDir, locales, outputDir, fallbackToSource: true })
+
+  const written = {}
+  if (projections) {
+    for (const [locale, { content: contentPath }] of Object.entries(content)) {
+      const translated = JSON.parse(await readFile(contentPath, 'utf-8'))
+      // The language's own records, where `buildLocalizedRecords` wrote them: `dist/<locale>/data/`.
+      const pages = await recordProjections(translated, { read: compiledData(join(outputDir, locale)), locale })
+      const files = projectionFiles(translated, pages)
+      for (const { fileName, source } of files) {
+        const target = join(outputDir, fileName)
+        await mkdir(dirname(target), { recursive: true })
+        await writeFile(target, source)
+      }
+      written[locale] = files
+    }
+  }
+
+  return { content, records, projections: written }
+}
+
 /**
  * Build translated site content for all locales
  * @param {string} siteRoot - Site root directory
  * @param {Object} options - Options
- * @param {boolean} [options.generateSearchIndexes=true] - Generate search indexes for each locale
  * @param {boolean} [options.freeformEnabled=true] - Enable free-form translation support
  * @returns {Object} Map of locale to output paths
  */
 export async function buildLocalizedContent(siteRoot, options = {}) {
+  // ⛔ It wrote each language's search index until 2026-10-25, from its pages alone and before its
+  // records were translated. A language's projections are `buildLocalizedSite`'s now.
+  if ('generateSearchIndexes' in options) {
+    throw new Error(
+      'buildLocalizedContent writes no search index: a language\'s search index, llms.txt and .md files are ' +
+        "written by buildLocalizedSite (`projections: true`), after the language's records are translated."
+    )
+  }
   const {
     localesDir = DEFAULTS.localesDir,
     locales = [],
     outputDir = join(siteRoot, 'dist'),
     fallbackToSource = true,
-    generateSearchIndexes = true,
     freeformEnabled = true
   } = options
 
@@ -456,20 +524,6 @@ export async function buildLocalizedContent(siteRoot, options = {}) {
     await writeFile(contentOutputPath, JSON.stringify(translated, null, 2))
 
     outputs[locale] = { content: contentOutputPath }
-
-    // Generate search index for this locale if search is enabled
-    if (generateSearchIndexes && searchDeclaredOn(translated)) {
-      const searchConfig = translated.config?.search || {}
-      const searchIndex = generateSearchIndex(translated, {
-        locale,
-        search: searchConfig
-      })
-
-      const searchOutputPath = join(localeOutputDir, 'search-index.json')
-      await writeFile(searchOutputPath, JSON.stringify(searchIndex, null, 2))
-
-      outputs[locale].searchIndex = searchOutputPath
-    }
   }
 
   return outputs

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

@@ -15,32 +15,22 @@
  * This function is the shared data-emission core used by the link-mode
  * pipeline. The vite plugin keeps its own emission for the bundle-mode
  * path (where the static-host extras — sitemap, robots, search-index,
- * `_pages/*` for split content — are actually consumed). Both paths use
+ * `llms.txt` and the `.md` projections, `_pages/*` for split content — are
+ * actually consumed). Both paths use
  * the same underlying building blocks (`collectSiteContent`,
  * `processQueries`, etc.), so behavior stays consistent without forcing
  * one path through the other's lifecycle. Media processing — WebP copies,
  * video posters, PDF thumbnails — is the bundle path's alone (below).
  */
 
-import { recordProjections, routeOnDisk } from './record-projections.js'
-import { writeFile, readFile, mkdir, cp } from 'node:fs/promises'
+import { writeFile, mkdir, cp } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { join, resolve, dirname } from 'node:path'
+import { join, resolve } from 'node:path'
 
 import { resolveDefaultLocale, DATA_DIR } from '@uniweb/core'
 import { collectSiteContent } from './content-collector.js'
 import { processQueries, writeQueryFiles } from './query-processor.js'
 import { resolveRecordsDir } from './entity-pool.js'
-import {
-  renderSiteIndex,
-  renderPageMarkdown,
-  resolveAgentsConfig,
-  selectIndexablePages,
-  selectIndexBranches,
-  pageMarkdownFilename,
-  branchIndexFilename,
-  INDEX_FILENAME
-} from '@uniweb/projections'
 
 /**
  * Build the site data for `uniweb build --link`, which `uniweb publish` runs.
@@ -98,6 +88,8 @@ import {
  *     described an emission its own step 5 had already removed, in the
  *     paragraph a reader consults BEFORE the code, and it was read as
  *     evidence by a downstream consumer.
+ *   - `llms.txt`, a branch's, or any page's `.md`, in any language — see step 6.
+ *     A host that serves the site derives its own from the content.
  *
  * @param {Object} params
  * @param {string} params.siteRoot - Absolute path to the site directory.
@@ -232,83 +224,11 @@ export async function buildSiteData({
   //    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.
-  //
-  //    Emitted here as well as in the vite plugin because both lanes publish
-  //    a site, and an artifact derived from site content has to exist
-  //    whichever lane produced it. A projection present after one publish and
-  //    absent after another is worse than none: agents are told to rely on it.
-  //
-  //    Ungated by `features:` — projections are free, so they carry no
-  //    billing intent and no entitlement to check downstream.
-  await writeProjections(finalContent, resolvedDistDir, join(resolvedSiteRoot, 'public'))
+  // 6. (removed 2026-10-25) This lane wrote `llms.txt` and a `.md` per page, for the default
+  //    language only, on the ground that both lanes publish a site. Nothing read them: `publish`
+  //    reads the schema-less query files and the languages, and a host that serves the site
+  //    derives its projections from the content, as it derives its search. The static host’s are
+  //    the bundle lane’s, in every language (`./projections.js`).
 
   return { siteContent: finalContent, distDir: resolvedDistDir }
 }
-
-/**
- * Write the agent projections into `distDir`.
- *
- * Mirrors the vite plugin's `emitProjections`, differing only in how bytes
- * reach disk (`writeFile` vs. Rollup's `emitFile`) — the generators, options
- * and filenames come from `@uniweb/projections`, so the two lanes cannot
- * disagree about what they produce.
- *
- * @param {Object} siteContent - Final site content for the default locale
- * @param {string} distDir - Resolved output directory
- * @param {string} dataRoot - where the compiled `/data/…` files are, for the record pages
- * @returns {Promise<void>}
- */
-async function writeProjections(siteContent, distDir, dataRoot) {
-  const agents = resolveAgentsConfig(siteContent?.config)
-  if (!agents.index && !agents.markdown) return
-  if (!siteContent?.pages?.length) return
-
-  const defaultLocale = resolveDefaultLocale(siteContent.config)
-  // ⭐ No address is assumed here: this lane builds for a host that serves the site, and states where
-  // (`config.url`). An author's static origin would send an agent to another copy of the site.
-  const options = {
-    address: siteContent.config?.url || null,
-    locale: siteContent.config?.activeLocale || defaultLocale,
-    defaultLocale
-  }
-  // Each record of a parametric page is a page, as a host lists them (`./record-projections.js`).
-  const records = recordProjections(siteContent, { dataRoot, locale: options.locale })
-
-  if (agents.index) {
-    const index = renderSiteIndex(siteContent, { ...options, exclude: agents.exclude, records: records.entries })
-    await writeFile(join(distDir, INDEX_FILENAME), index)
-
-    // Additive scoped indexes; the root one above stays complete. See
-    // `selectIndexBranches` for why this is not a delegation.
-    if (agents.branchIndexes) {
-      const branches = selectIndexBranches(siteContent.pages, {
-        exclude: agents.exclude,
-        minPages: agents.branchMinPages
-      })
-      for (const branch of branches) {
-        const target = join(distDir, branchIndexFilename(branch.route))
-        await mkdir(dirname(target), { recursive: true })
-        await writeFile(
-          target,
-          renderSiteIndex(siteContent, { ...options, exclude: agents.exclude, records: records.entries, branch: branch.route })
-        )
-      }
-    }
-  }
-
-  if (!agents.markdown) return
-
-  for (const page of selectIndexablePages(siteContent.pages, { exclude: agents.exclude })) {
-    const markdown = renderPageMarkdown(page)
-    if (!markdown) continue
-    const target = join(distDir, pageMarkdownFilename(page.route))
-    await mkdir(dirname(target), { recursive: true })
-    await writeFile(target, markdown)
-  }
-  for (const { route, markdown } of selectIndexablePages(records.pages, { exclude: agents.exclude })) {
-    const target = join(distDir, pageMarkdownFilename(routeOnDisk(route)))
-    await mkdir(dirname(target), { recursive: true })
-    await writeFile(target, markdown)
-  }
-}

package/src/site/config.js

@@ -40,6 +40,7 @@ import { readPreview, PREVIEW_ENV } from './preview.js'
 import { previewMediaPlugin } from './preview-media.js'
 import { previewDirectoryIndexPlugin } from './preview-directory-index.js'
 import { devServerRecordPlugin, requestedDevPort } from './dev-server.js'
+import { refuseSearchOption } from './search-declared.js'
 
 /**
  * Normalize a base path for Vite compatibility
@@ -108,7 +109,6 @@ export function readSiteConfig(siteRoot) {
  *   a site's `vite.config.js` is scaffolding, so nothing a site GETS may depend
  *   on what it passes here.
  * @param {Object} [options.assets] - Asset processing configuration
- * @param {Object} [options.search] - Search index configuration
  * @param {boolean} [options.tailwind] - Include Tailwind CSS v4 Vite plugin (default: true)
  * @param {string} [options.base] - Base public path for deployment (e.g., '/demos/mysite/')
  * @returns {Promise<Object>} Vite configuration
@@ -138,6 +138,7 @@ function runtimeAnchor(siteRoot) {
 }
 
 export async function defineSiteConfig(options = {}) {
+  refuseSearchOption(options, 'defineSiteConfig')
   const {
     plugins: extraPlugins = [],
     server: serverOverrides = {},
@@ -146,7 +147,6 @@ export async function defineSiteConfig(options = {}) {
     optimizeDeps: optimizeDepsOverrides = {},
     seo = {},
     assets = {},
-    search = {},
     tailwind = true,
     base: baseOption,
     ...restOptions
@@ -333,7 +333,6 @@ export async function defineSiteConfig(options = {}) {
       sitePath: './',
       seo,
       assets,
-      search,
       foundationPath: foundationInfo.path // For loading foundation theme vars
     }),
 

package/src/site/plugin.js

@@ -30,18 +30,7 @@ import { resolve, join, relative, sep } from 'node:path'
 import { watch, existsSync } from 'node:fs'
 import { readFile, readdir } from 'node:fs/promises'
 import { resolveDefaultLocale, resolveFetchConfigs, DATA_DIR } from '@uniweb/core'
-import {
-  renderSiteIndex,
-  renderPageMarkdown,
-  resolveAgentsConfig,
-  selectIndexablePages,
-  selectIndexBranches,
-  pageMarkdownFilename,
-  branchIndexFilename,
-  applyRouteTranslation,
-  partitionKnowledgePages,
-  INDEX_FILENAME
-} from '@uniweb/projections'
+import { partitionKnowledgePages, INDEX_FILENAME } from '@uniweb/projections'
 import { collectSiteContent, mountEntriesOf } from './content-collector.js'
 import { processAssets, rewriteSiteContentPaths } from './asset-processor.js'
 import { processAdvancedAssets } from './advanced-processors.js'
@@ -266,20 +255,13 @@ async function processDevSectionFetches(sections, fetchOptions, resolve) {
     }
   }
 }
-import { generateSearchIndex, getSearchIndexFilename, mergeSearchIndexes } from '@uniweb/projections'
-import { recordProjections, routeOnDisk } from './record-projections.js'
+import { compiledData, recordProjections, routeOnDisk } from './record-projections.js'
+import { agentFiles, describeProjections, projectionFiles, searchFiles } from './projections.js'
 import { mergeTranslations } from '../i18n/merge.js'
 import { dataBlockModels, NO_DATA_MODELS } from '../i18n/data-models.js'
-import { searchDeclaredOn } from './search-declared.js'
+import { refuseSearchOption } from './search-declared.js'
 import { mountDevApi } from '../dev/api-mount.js'
 
-/*
- * `applyRouteTranslation` now comes from `@uniweb/projections` (imported
- * above). It used to be defined here; the agent index builds localized URLs
- * from the same rule, and two copies would eventually disagree about where a
- * localized page lives.
- */
-
 /**
  * Create the site content plugin
  *
@@ -303,11 +285,10 @@ import { mountDevApi } from '../dev/api-mount.js'
  * @param {string} [options.assets.outputDir='assets'] - Output subdirectory for processed assets
  * @param {boolean} [options.assets.videoPosters=true] - Extract poster frames from videos (requires ffmpeg)
  * @param {boolean} [options.assets.pdfThumbnails=true] - Generate thumbnails for PDFs (requires pdf-lib)
- * @param {Object} [options.search] - Search index configuration
- * @param {boolean} [options.search.enabled=true] - Generate search index (uses site.yml config by default)
  * @param {string} [options.foundationPath] - Path to foundation directory (for loading theme vars)
  */
 export function siteContentPlugin(options = {}) {
+  refuseSearchOption(options, 'siteContentPlugin')
   const {
     sitePath = './',
     pagesDir = 'pages',
@@ -317,7 +298,6 @@ export function siteContentPlugin(options = {}) {
     watch: shouldWatch = true,
     seo = {},
     assets: assetsConfig = {},
-    search: searchPluginConfig = {},
     foundationPath
   } = options
 
@@ -480,9 +460,9 @@ export function siteContentPlugin(options = {}) {
   }
 
   /**
-   * Materialize every query the site declares into `public/data/` — at dev startup,
-   * and again whenever what a query file is made from changes (`siteRootChange`, and
-   * an entity change).
+   * Materialize every query the site declares into `public/data/` — at a production
+   * build's start, at dev startup, and again whenever what a query file is made from
+   * changes (`siteRootChange`, and an entity change).
    *
    * @param {Object|undefined} queries - the collected `config.queries`
    * @param {Object|undefined} config - the collected `config`, for the default locale a `sort` collates in
@@ -559,112 +539,64 @@ export function siteContentPlugin(options = {}) {
   }
 
   /**
-   * Options shared by every projection call, so the dev middleware and the
-   * build emit cannot drift apart in how they build URLs.
+   * The site's content in `locale`, as a page in that language gets it — or null when the site has
+   * no translation for it (`getTranslatedContent`).
    */
-  function projectionOptions(content) {
-    const defaultLocale = resolveDefaultLocale(content.config)
-    return {
-      // Absolute on the site's address when it is known, else from the base (`buildPageUrl`).
-      address: content.config?.url || null,
-      basePath,
-      locale: content.config?.activeLocale || defaultLocale,
-      defaultLocale
-    }
+  async function languageContent(locale) {
+    const translated = await getTranslatedContent(locale)
+    return translated && { ...translated, config: { ...translated.config, activeLocale: locale } }
   }
 
   /**
-   * Emit `llms.txt` and the per-page `.md` projections.
-   *
-   * Called with the Rollup plugin context, so `this.emitFile` is available.
-   * Sits beside the sitemap and search-index emits because it is the same kind
-   * of thing: an artifact derived from the site's content alone.
-   *
-   * Unlike the sitemap, this does NOT skip when the site's address is unknown
-   * — it falls back to root-relative links and `uniweb doctor` warns.
-   * An agent that arrived via the index can still follow a relative link, and
-   * a silently-absent index is the failure mode the whole feature exists to
-   * prevent.
-   *
-   * @param {Object} content - Final site content for this locale
-   * @param {Object} [records] - its record pages (`recordProjections`), listed and written as pages
+   * A compiled data file in `locale` — a query's list (`articles.json`) or a record's own file
+   * (`articles/<$name>.json`), by its path under `data/` — translated as the localized build
+   * translates it (`buildLocalizedRecords`), by the same helpers (`translateRecordData`). Null when
+   * the site compiled no such file.
    */
-  function emitProjections(content, records = recordProjections(content, { dataRoot: resolvedPublicDir })) {
-    const agents = resolveAgentsConfig(content?.config)
-    if (!agents.index && !agents.markdown) return
-    if (!content?.pages?.length) return
-
-    const options = projectionOptions(content)
-    const localeDir =
-      options.locale && options.defaultLocale && options.locale !== options.defaultLocale
-        ? `${options.locale}/`
-        : ''
-
-    if (agents.index) {
-      this.emitFile({
-        type: 'asset',
-        fileName: `${localeDir}${INDEX_FILENAME}`,
-        source: renderSiteIndex(content, { ...options, exclude: agents.exclude, records: records.entries })
-      })
-      console.log(`[site-content] Generated ${localeDir}${INDEX_FILENAME}`)
-
-      // Branch indexes are ADDITIVE — the root index above still enumerates
-      // every page, because the two-hop criterion depends on it. These are a
-      // scoped entry point for an agent already inside a branch.
-      if (agents.branchIndexes) {
-        const branches = selectIndexBranches(content.pages, {
-          exclude: agents.exclude,
-          minPages: agents.branchMinPages
-        })
-        for (const branch of branches) {
-          this.emitFile({
-            type: 'asset',
-            fileName: `${localeDir}${branchIndexFilename(branch.route)}`,
-            source: renderSiteIndex(content, {
-              ...options,
-              exclude: agents.exclude,
-              records: records.entries,
-              branch: branch.route
-            })
-          })
-        }
-        if (branches.length) {
-          const names = branches.map(b => `${b.route} (${b.count})`).join(', ')
-          console.log(`[site-content] Generated ${branches.length} branch index(es): ${names}`)
-        }
-      }
-    }
+  async function localizedDataFile(locale, filename) {
+    const sourcePath = join(resolvedSitePath, 'public', DATA_DIR, filename)
+    if (!existsSync(sourcePath)) return null
+    const items = JSON.parse(await readFile(sourcePath, 'utf-8'))
+    const record = filename.includes('/') && items && typeof items === 'object' && !Array.isArray(items)
+    if (!Array.isArray(items) && !record) return items
+    const queryName = record ? filename.slice(0, filename.lastIndexOf('/')) : filename.replace(/\.json$/, '')
+    const { translateRecordData } = await import('../i18n/records.js')
+    return translateRecordData(items, queryName, resolvedSitePath, {
+      locale,
+      localesDir: join(resolvedSitePath, localesDir),
+      translations: (await loadRecordTranslations(locale)) || {},
+      freeformEnabled: existsSync(join(resolvedSitePath, localesDir, 'freeform', locale))
+    })
+  }
 
-    if (agents.markdown) {
-      const pages = selectIndexablePages(content.pages, { exclude: agents.exclude })
-      let emitted = 0
-      for (const page of pages) {
-        const markdown = renderPageMarkdown(page)
-        if (!markdown) continue
-        const route =
-          options.locale !== options.defaultLocale
-            ? applyRouteTranslation(page.route, options.locale, content.config?.i18n?.routeTranslations)
-            : page.route
-        this.emitFile({
-          type: 'asset',
-          fileName: `${localeDir}${pageMarkdownFilename(route)}`,
-          source: markdown
-        })
-        emitted++
-      }
-      // Each record's page, under the exclusions a page is held to.
-      const listed = new Set(selectIndexablePages(records.pages, { exclude: agents.exclude }).map((page) => page.route))
-      for (const { route, markdown } of records.pages) {
-        if (!listed.has(route)) continue
-        this.emitFile({
-          type: 'asset',
-          fileName: `${localeDir}${pageMarkdownFilename(routeOnDisk(route))}`,
-          source: markdown
-        })
-        emitted++
-      }
-      if (emitted) console.log(`[site-content] Generated ${emitted} page markdown projections`)
-    }
+  /**
+   * The projection a dev request names — the search index, an agent index, a page's markdown — made
+   * as the build makes it: by the same function, from the same language's content and records
+   * (`./projections.js`). A request under a language's prefix is that language's when the site has
+   * content in it; any other is the default language's. Null when the build writes no such file.
+   *
+   * @param {string} url - the request's path
+   * @returns {Promise<{ source: string, type: string }|null>}
+   */
+  async function devProjection(url) {
+    const search = url.endsWith('/search-index.json')
+    const markdown = url.endsWith('.md')
+    if (!search && !markdown && !url.endsWith(`/${INDEX_FILENAME}`)) return null
+    if (!siteContent) return null
+    // A static host decodes a request's path before it looks for the file.
+    const fileName = routeOnDisk(url).replace(/^\/+/, '')
+    const locale = fileName.match(new RegExp(`^(${LOCALE_RE})/`))?.[1]
+    const localized = locale ? await languageContent(locale) : null
+    const content = localized || siteContent
+    // A language's records, translated as its build translates them; the default's, as compiled.
+    const read = localized
+      ? (path) => (path.startsWith(`/${DATA_DIR}/`) ? localizedDataFile(locale, path.slice(DATA_DIR.length + 2)) : null)
+      : compiledData(resolvedPublicDir)
+    const records = await recordProjections(content, { read })
+    const file = (search ? searchFiles(content, records) : agentFiles(content, records)).find((f) => f.fileName === fileName)
+    if (!file) return null
+    const type = search ? 'application/json' : markdown ? 'text/markdown; charset=utf-8' : 'text/plain; charset=utf-8'
+    return { source: file.source, type }
   }
 
   return {
@@ -734,11 +666,12 @@ export function siteContentPlugin(options = {}) {
 
         // Materialize each query if the site declares any.
         // In dev mode, this was already done in configResolved (before server starts)
-        // In production, do it here
+        // In production, do it here — by the same call, so a `sort` collates in the site's default
+        // language in both. ⛔ Until 2026-10-25 this called `processQueries` with no language, and
+        // the built file was collated in English whatever the site's language.
         if (isProduction && siteContent.config?.queries) {
           console.log('[site-content] Materializing queries...')
-          const byQuery = await processQueries(resolvedSitePath, siteContent.config.queries, resolvedRecordsDir, basePath)
-          await writeQueryFiles(resolvedSitePath, byQuery, siteContent.config.queries)
+          await materializeQueries(siteContent.config.queries, siteContent.config)
         }
 
         // Execute data fetches in dev mode
@@ -1079,106 +1012,19 @@ export function siteContentPlugin(options = {}) {
         // ⛔ No sitemap.xml or robots.txt here: the prerender writes them from the pages it
         // renders (`./seo-files.js`), and a dev server renders none ahead of a visit.
 
-        // Serve search-index.json in dev mode, under a language's prefix too.
-        // ⚠️ Made from the default language's content whatever the prefix, and with no records for
-        // another language: the build's `/fr/search-index.json` is in French, this one is not
-        // (measured 2026-10-25).
-        const searchIndexMatch = req.url.match(new RegExp(`^(?:\\/(${LOCALE_RE}))?\\/search-index\\.json$`))
-        if (searchIndexMatch && siteContent) {
-          const searchEnabled = searchPluginConfig.enabled !== false && searchDeclaredOn(siteContent)
-          if (searchEnabled) {
-            const searchConfig = siteContent.config?.search || {}
-            const defaultLocale = resolveDefaultLocale(siteContent.config)
-            // Use requested locale from URL, fall back to active or default
-            const requestedLocale = searchIndexMatch[1]
-            const activeLocale = requestedLocale || siteContent.config?.activeLocale || defaultLocale
-
-            const pagesIndex = generateSearchIndex(siteContent, {
-              locale: activeLocale,
-              search: searchConfig
-            })
-            // The record pages, as the build lists them — the default locale's, whose records these are.
-            const searchIndex = activeLocale === defaultLocale
-              ? mergeSearchIndexes(pagesIndex, recordProjections(siteContent, { dataRoot: resolvedPublicDir, locale: activeLocale }).indexes)
-              : pagesIndex
-
-            res.setHeader('Content-Type', 'application/json')
-            res.end(JSON.stringify(searchIndex, null, 2))
-            return
-          }
-        }
-
-        // Serve the agent projections in dev mode.
-        //
-        // Without this the artifacts can only be inspected by deploying, and
-        // `uniweb doctor`'s address warning describes something invisible
-        // locally. Both routes reuse the build's generators, so what a
-        // developer sees here is what ships — for the default language.
-        // ⚠️ Not for another one (measured 2026-10-25): the build writes it no `llms.txt` or `.md`,
-        // and the `.md` route below finds a page by its source route, so the translated links this
-        // `llms.txt` gives (`/fr/a-propos.md`) are answered with the page shell.
-        if (siteContent) {
-          const agents = resolveAgentsConfig(siteContent.config)
-          const url = req.url.split('?')[0]
-
-          // `/llms.txt`, `/fr/llms.txt`, and the branch form `/docs/llms.txt`.
-          // The optional middle group is the branch route; an empty one is the
-          // site index, so a single pattern serves both rather than two that
-          // could drift.
-          const indexMatch = url.match(
-            new RegExp(`^(?:\\/(${LOCALE_RE}))?((?:\\/[^/]+)*)\\/${INDEX_FILENAME}$`)
-          )
-          if (indexMatch && agents.index) {
-            const localized = (indexMatch[1] ? await getTranslatedContent(indexMatch[1]) : null) || siteContent
-            const branch = indexMatch[2] || null
-
-            // Serve a branch index only where the build would emit one, or dev
-            // and the built output disagree about which URLs exist.
-            const served =
-              !branch ||
-              (agents.branchIndexes &&
-                selectIndexBranches(localized.pages, {
-                  exclude: agents.exclude,
-                  minPages: agents.branchMinPages
-                }).some(b => b.route === branch))
-
-            if (served) {
-              // The record pages, as the build lists them — the default locale's, whose records these are.
-              const records = localized === siteContent
-                ? recordProjections(siteContent, { dataRoot: resolvedPublicDir }).entries
-                : undefined
-              res.setHeader('Content-Type', 'text/plain; charset=utf-8')
-              res.end(
-                renderSiteIndex(localized, {
-                  ...projectionOptions(localized),
-                  locale: indexMatch[1] || projectionOptions(localized).locale,
-                  exclude: agents.exclude,
-                  records,
-                  branch
-                })
-              )
-              return
-            }
-          }
-
-          const markdownMatch = url.match(new RegExp(`^(?:\\/(${LOCALE_RE}))?\\/(.+)\\.md$`))
-          if (markdownMatch && agents.markdown) {
-            const localized = (markdownMatch[1] ? await getTranslatedContent(markdownMatch[1]) : null) || siteContent
-            const requested = markdownMatch[2] === 'index' ? '/' : `/${markdownMatch[2]}`
-            const pages = selectIndexablePages(localized.pages, { exclude: agents.exclude })
-            const page = pages.find(p => p.route === requested)
-            const markdown = page
-              ? renderPageMarkdown(page)
-              : localized === siteContent
-                ? selectIndexablePages(recordProjections(siteContent, { dataRoot: resolvedPublicDir }).pages, { exclude: agents.exclude })
-                  .find((record) => routeOnDisk(record.route) === routeOnDisk(requested))?.markdown
-                : null
-            if (markdown) {
-              res.setHeader('Content-Type', 'text/markdown; charset=utf-8')
-              res.end(markdown)
-              return
-            }
-          }
+        // The projections — the search index, `llms.txt` (and a branch's), each page as markdown —
+        // in every language: the file the build writes at this path, made by the same function from
+        // the same language's content and records (`devProjection`), so what a developer sees here
+        // is what ships. Without it they could be inspected only by deploying, and `uniweb doctor`'s
+        // address warning would describe something invisible locally. ⛔ Until 2026-10-25 dev made
+        // another language's search index from the default language's content, and found its `.md`
+        // by the source route, so the translated links its `llms.txt` gave answered with the page
+        // shell.
+        const projection = await devProjection(req.url.split('?')[0])
+        if (projection) {
+          res.setHeader('Content-Type', projection.type)
+          res.end(projection.source)
+          return
         }
 
         // Handle localized collection data (e.g., /fr/data/articles.json), and a
@@ -1186,45 +1032,16 @@ export function siteContentPlugin(options = {}) {
         // each, translated the same way.
         const localeDataMatch = req.url.match(new RegExp(`^\\/(${LOCALE_RE})\\/${DATA_DIR}\\/(.+\\.json)$`))
         if (localeDataMatch) {
-          const locale = localeDataMatch[1]
-          const filename = localeDataMatch[2]
-          const sourcePath = join(resolvedSitePath, 'public', DATA_DIR, filename)
-
-          if (existsSync(sourcePath)) {
-            try {
-              const raw = await readFile(sourcePath, 'utf-8')
-              const items = JSON.parse(raw)
-              const record = filename.includes('/') && items && typeof items === 'object' && !Array.isArray(items)
-              if (!Array.isArray(items) && !record) {
-                res.setHeader('Content-Type', 'application/json')
-                res.end(raw)
-                return
-              }
-              const queryName = record ? filename.slice(0, filename.lastIndexOf('/')) : filename.replace(/\.json$/, '')
-
-              // Load collection translations for this locale
-              const translations = await loadRecordTranslations(locale) || {}
-
-              // Check for free-form translations
-              const freeformDir = join(resolvedSitePath, localesDir, 'freeform', locale)
-              const hasFreeform = existsSync(freeformDir)
-
-              // Translate using the collections module
-              const { translateRecordData } = await import('../i18n/records.js')
-              const translated = await translateRecordData(items, queryName, resolvedSitePath, {
-                locale,
-                localesDir: join(resolvedSitePath, localesDir),
-                translations,
-                freeformEnabled: hasFreeform
-              })
-
+          try {
+            const translated = await localizedDataFile(localeDataMatch[1], localeDataMatch[2])
+            if (translated !== null) {
               res.setHeader('Content-Type', 'application/json')
               res.end(JSON.stringify(translated, null, 2))
               return
-            } catch (err) {
-              console.warn(`[site-content] Failed to serve localized records ${filename}: ${err.message}`)
-              // Fall through to Vite's static server
             }
+          } catch (err) {
+            console.warn(`[site-content] Failed to serve localized records ${localeDataMatch[2]}: ${err.message}`)
+            // Fall through to Vite's static server
           }
         }
 
@@ -1451,40 +1268,14 @@ export function siteContentPlugin(options = {}) {
       // sitemap.xml and robots.txt are the prerender's: it writes them from the pages it wrote,
       // record pages included (`./seo-files.js`).
 
-      // The site's record pages — each record of a parametric page — for its search index and its
-      // agent projections, as a host makes them (`./record-projections.js`).
-      const records = recordProjections(finalContent, {
-        dataRoot: resolvedPublicDir,
-        locale: finalContent.config?.activeLocale || resolveDefaultLocale(finalContent.config)
-      })
-
-      // Generate search index if enabled
-      const searchEnabled = searchPluginConfig.enabled !== false && searchDeclaredOn(finalContent)
-      if (searchEnabled) {
-        const searchConfig = finalContent.config?.search || {}
-        const defaultLocale = resolveDefaultLocale(finalContent.config)
-        const activeLocale = finalContent.config?.activeLocale || defaultLocale
-
-        // Generate search index for current locale — its pages, and its records' pages
-        const searchIndex = mergeSearchIndexes(
-          generateSearchIndex(finalContent, { locale: activeLocale, search: searchConfig }),
-          records.indexes
-        )
-
-        const searchFilename = getSearchIndexFilename(activeLocale, defaultLocale)
-        this.emitFile({
-          type: 'asset',
-          fileName: searchFilename,
-          source: JSON.stringify(searchIndex, null, 2)
-        })
-
-        console.log(`[site-content] Generated ${searchFilename} (${searchIndex.count} entries)`)
-      }
-
-      // Agent-readable projections: the index (discovery) and per-page
-      // markdown (retrieval). Free and on by default; a site opts out under
-      // `agents:` in site.yml.
-      emitProjections.call(this, finalContent, records)
+      // The default language's projections — its search index, its agent index and its pages as
+      // markdown, each record of a parametric page among them — by the rule every language's are
+      // made by (`./projections.js`). Each other language's are written after the bundle, once its
+      // records are translated (`i18n/index.js::buildLocalizedSite`).
+      const records = await recordProjections(finalContent, { read: compiledData(resolvedPublicDir) })
+      const projected = projectionFiles(finalContent, records)
+      for (const { fileName, source } of projected) this.emitFile({ type: 'asset', fileName, source })
+      for (const line of describeProjections(projected)) console.log(`[site-content] ${line}`)
 
       // A site-relative extension (`/effects/entry.js`) is served from the
       // site's OWN origin, so the site's build is what has to put it there.

package/src/site/projections.js

@@ -0,0 +1,188 @@
+/**
+ * A LANGUAGE'S PROJECTIONS — the files a static host serves about a site in one of its languages:
+ * its search index, its agent index (`llms.txt`, and a branch's), and each of its pages as markdown,
+ * a record's page included. Made from that language's content and its records alone; the
+ * generators are `@uniweb/projections`', and this decides which of them a site gets and where each
+ * file goes.
+ *
+ * ⭐ ONE RULE, EVERY WRITER. The bundle build emits the default language's through Rollup
+ * (`./plugin.js`), the localized build writes each other language's once its records are translated
+ * (`i18n/index.js::buildLocalizedSite`), and the dev server answers a request with the file named
+ * for it here — so what a developer sees is what ships, in every language. ⛔ Until 2026-10-25 four
+ * writers made these files, and they disagreed: another language's search index was made from its
+ * pages alone, before its records were translated, and it got no `llms.txt` or `.md`; dev made every
+ * language's search index from the default language's content. Measured on a starter in three
+ * languages with three record pages: 20 search entries in English, 17 in French and Spanish, and no
+ * `fr/llms.txt`.
+ *
+ * ⭐ A LANGUAGE'S FILES ARE AT ITS ADDRESSES: under its prefix, at its translated routes
+ * (`applyRouteTranslation`) — `fr/actualites/x.md` for `/blog/x` — where its `llms.txt` links them
+ * (`buildPageUrl`). A static host decodes a request's path before it looks for the file, so a
+ * record's file is named for its decoded route (`routeOnDisk`).
+ *
+ * @module
+ */
+
+import { resolveDefaultLocale } from '@uniweb/core'
+import {
+  renderSiteIndex,
+  renderPageMarkdown,
+  resolveAgentsConfig,
+  selectIndexablePages,
+  selectIndexBranches,
+  pageMarkdownFilename,
+  branchIndexFilename,
+  applyRouteTranslation,
+  generateSearchIndex,
+  getSearchIndexFilename,
+  mergeSearchIndexes,
+  INDEX_FILENAME
+} from '@uniweb/projections'
+import { routeOnDisk } from './record-projections.js'
+import { searchDeclaredOn } from './search-declared.js'
+
+/**
+ * The language `content` is in — its `config.activeLocale`, else the site's default — the prefix
+ * its files go under, and the route a visitor reaches a page at in it.
+ */
+function languageOf(content) {
+  const config = content?.config || {}
+  const defaultLocale = resolveDefaultLocale(config)
+  const locale = config.activeLocale || defaultLocale
+  const other = Boolean(locale && defaultLocale && locale !== defaultLocale)
+  const routeTranslations = config.i18n?.routeTranslations
+  return {
+    locale,
+    defaultLocale,
+    prefix: other ? `${locale}/` : '',
+    at: other ? (route) => applyRouteTranslation(route, locale, routeTranslations) : (route) => route
+  }
+}
+
+/**
+ * The language's search index, when the site has search (`services.search`, `./search-declared.js`):
+ * its pages, then its records' pages.
+ *
+ * @param {Object} content - one language's site content
+ * @param {Object} [records] - its record pages (`recordProjections`)
+ * @returns {Array<{ kind: 'search', fileName: string, source: string, count: number }>}
+ */
+export function searchFiles(content, records) {
+  if (!searchDeclaredOn(content)) return []
+  const { locale, defaultLocale } = languageOf(content)
+  const index = mergeSearchIndexes(
+    generateSearchIndex(content, { locale, search: content.config?.search || {} }),
+    records?.indexes
+  )
+  return [
+    {
+      kind: 'search',
+      fileName: getSearchIndexFilename(locale, defaultLocale),
+      source: JSON.stringify(index, null, 2),
+      count: index.count
+    }
+  ]
+}
+
+/**
+ * The language's agent projections, unless the site turns them off (`agents:`): `llms.txt` — and a
+ * branch's, where `branchIndexes` asks for them — and each page it lists, as markdown.
+ *
+ * Unlike the sitemap, written when the site's address is unknown too: the links are root-relative
+ * then, and `uniweb doctor` warns. An agent that arrived through the index can follow a relative
+ * link, and a silently absent index is the failure the whole feature exists to prevent.
+ *
+ * @param {Object} content - one language's site content
+ * @param {Object} [records] - its record pages (`recordProjections`), listed and written as pages
+ * @returns {Array<{ kind: 'index'|'branch'|'markdown', fileName: string, source: string }>}
+ */
+export function agentFiles(content, records) {
+  const agents = resolveAgentsConfig(content?.config)
+  if (!agents.index && !agents.markdown) return []
+  if (!content?.pages?.length) return []
+
+  const { locale, defaultLocale, prefix, at } = languageOf(content)
+  // The address and base path are the content's own (`config.url`, `config.base`), which
+  // `renderSiteIndex` reads.
+  const options = { locale, defaultLocale, exclude: agents.exclude, records: records?.entries }
+  const files = []
+
+  if (agents.index) {
+    files.push({ kind: 'index', fileName: `${prefix}${INDEX_FILENAME}`, source: renderSiteIndex(content, options) })
+
+    // Branch indexes are ADDITIVE — the root index above still lists every page, because the
+    // two-hop criterion depends on it. These are a scoped entry point for an agent already inside
+    // a branch, at the branch's own address.
+    if (agents.branchIndexes) {
+      const branches = selectIndexBranches(content.pages, { exclude: agents.exclude, minPages: agents.branchMinPages })
+      for (const branch of branches) {
+        files.push({
+          kind: 'branch',
+          fileName: `${prefix}${branchIndexFilename(at(branch.route))}`,
+          source: renderSiteIndex(content, { ...options, branch: branch.route }),
+          route: branch.route,
+          count: branch.count
+        })
+      }
+    }
+  }
+
+  if (agents.markdown) {
+    for (const page of selectIndexablePages(content.pages, { exclude: agents.exclude })) {
+      const markdown = renderPageMarkdown(page)
+      if (markdown) files.push({ kind: 'markdown', fileName: `${prefix}${pageMarkdownFilename(at(page.route))}`, source: markdown })
+    }
+    // Each record's page, held to the exclusions a page is held to — the site's pages among them,
+    // so a record under a branch `llms.txt` leaves out gets no file, as it gets no line there.
+    const listed = indexableRecordRoutes(content.pages, records?.pages, agents.exclude)
+    for (const { route, markdown } of records?.pages || []) {
+      if (!listed.has(route)) continue
+      files.push({ kind: 'markdown', fileName: `${prefix}${pageMarkdownFilename(routeOnDisk(at(route)))}`, source: markdown })
+    }
+  }
+
+  return files
+}
+
+/**
+ * Every projection of one language of a site: its search index, then its agent projections.
+ *
+ * @param {Object} content - one language's site content
+ * @param {Object} [records] - its record pages (`recordProjections`)
+ */
+export function projectionFiles(content, records) {
+  return [...searchFiles(content, records), ...agentFiles(content, records)]
+}
+
+/**
+ * What a build says it wrote — one line per kind of file.
+ *
+ * @param {Array<{ kind: string, fileName: string }>} files - `projectionFiles`
+ * @returns {string[]}
+ */
+export function describeProjections(files) {
+  const lines = []
+  for (const file of files) {
+    if (file.kind === 'search') lines.push(`Generated ${file.fileName} (${file.count} entries)`)
+    if (file.kind === 'index') lines.push(`Generated ${file.fileName}`)
+  }
+  const branches = files.filter((file) => file.kind === 'branch')
+  if (branches.length) {
+    lines.push(`Generated ${branches.length} branch index(es): ${branches.map((b) => `${b.route} (${b.count})`).join(', ')}`)
+  }
+  const markdown = files.filter((file) => file.kind === 'markdown').length
+  if (markdown) lines.push(`Generated ${markdown} page markdown projections`)
+  return lines
+}
+
+/** The routes of the record pages `llms.txt` lists, judged among the site's own pages. */
+function indexableRecordRoutes(pages = [], recordPages = [], exclude) {
+  if (!recordPages?.length) return new Set()
+  const routes = new Set(recordPages.map((page) => page.route))
+  const candidates = [...pages, ...recordPages.map(({ route }) => ({ route }))]
+  return new Set(
+    selectIndexablePages(candidates, { exclude })
+      .map((page) => page.route)
+      .filter((route) => routes.has(route))
+  )
+}

package/src/site/record-projections.js

@@ -9,13 +9,15 @@
  * and the search index held none of a site's books, talks or posts, while a host's held all of them
  * (measured on a site with 16 record pages: 0 in llms.txt, 0 in the search index).
  *
- * ⚠️ For the default language only. Another language's search index is still made from its pages
- * alone, before its records are translated (`i18n/index.js::buildLocalizedContent`), and the build
- * writes that language no llms.txt or `.md` (measured 2026-10-25 on a site in three languages).
+ * ⭐ In every language, each from its own records: the caller says where a language's compiled files
+ * are by how it reads them (`read`) — the default language's under `public/`, another's under
+ * `dist/<locale>/` once they are translated, and dev's translated as they are asked for. ⛔ The same
+ * day, the static build listed the record pages of its default language only (`./projections.js`).
  */
 
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
+import { resolveDefaultLocale } from '@uniweb/core/locale-config'
 import { fillRoutePattern, recordHandle } from '@uniweb/core/route-match'
 import { recordRoutes, generateRecordSearchIndex, renderPageMarkdown } from '@uniweb/projections'
 
@@ -41,18 +43,35 @@ function readJson(file) {
   }
 }
 
+/**
+ * A reader of the compiled data files under `root` — the directory a query's compiled `path`
+ * (`/data/talks.json`) is under: `public/` for the default language, `dist/<locale>/` for another.
+ *
+ * @param {string} root
+ * @returns {(path: string) => *} the file's JSON, or null when there is none
+ */
+export function compiledData(root) {
+  return (path) => readJson(join(root, path))
+}
+
 /**
  * The record pages of a site: each query whose records have a page of their own, with its search
  * index and each record's page — its route, and its markdown (the parametric page's, then the
  * record).
  *
- * @param {Object} content - one locale's site content
+ * @param {Object} content - one language's site content
  * @param {Object} options
- * @param {string} options.dataRoot - the directory a query's compiled `path` (`/data/talks.json`) is under
- * @param {string} [options.locale]
- * @returns {{ indexes: Object[], entries: Object[], pages: Array<{ route: string, markdown: string }> }}
+ * @param {(path: string) => *} options.read - a compiled data file's JSON in that language, by its
+ *   site path (`/data/talks.json`, a record's own `/data/talks/<$name>.json`), or null — a promise of
+ *   one too (`compiledData`)
+ * @param {string} [options.locale] - the content's language, `config.activeLocale` by default, else
+ *   the site's default
+ * @returns {Promise<{ indexes: Object[], entries: Object[], pages: Array<{ route: string, markdown: string }> }>}
  */
-export function recordProjections(content, { dataRoot, locale } = {}) {
+export async function recordProjections(
+  content,
+  { read, locale = content?.config?.activeLocale || resolveDefaultLocale(content?.config || {}) } = {}
+) {
   const queries = content?.config?.queries || {}
   const indexes = []
   const pages = []
@@ -60,19 +79,19 @@ export function recordProjections(content, { dataRoot, locale } = {}) {
     // No compiled file: a query answered by a records service, or an external one — its records
     // are not this build's to list.
     if (!path) continue
-    const records = readJson(join(dataRoot, path))
+    const records = await read(path)
     if (!Array.isArray(records)) continue
     indexes.push(generateRecordSearchIndex(name, { ...(queries[name] || {}), pattern, field }, records, locale))
 
     const template = (content.pages || []).find((page) => page.route === pattern)
     if (!template) continue
     // A record's own file holds it whole; the list holds its brief.
-    const wholeDir = join(dataRoot, path.replace(/\.json$/, ''))
+    const wholeDir = path.replace(/\.json$/, '')
     for (const brief of records) {
       const route = fillRoutePattern(pattern, brief, { field: field ?? null })
       if (!route) continue
       const handle = recordHandle(brief)
-      const record = (handle && readJson(join(wholeDir, `${handle}.json`))) || brief
+      const record = (handle && (await read(`${wholeDir}/${handle}.json`))) || brief
       const markdown = renderPageMarkdown(template, { record })
       if (markdown) pages.push({ route, markdown })
     }

package/src/site/search-declared.js

@@ -32,3 +32,21 @@ export function searchDeclaredOn(siteContent) {
   if (typeof search === 'boolean') return search
   return search?.enabled !== false
 }
+
+/**
+ * ⛔ A site's Vite config no longer says whether the site has search — retired 2026-10-25. Its
+ * `search` option reached the default language's index alone: every other language's is written
+ * after the bundle, where no Vite config is read (`i18n/index.js::buildLocalizedSite`). And a site's
+ * `vite.config.js` is scaffolding, so nothing a site gets may depend on it. `site.yml` decides, for
+ * every language (`searchDeclaredOn`).
+ *
+ * @param {Object} options - what `defineSiteConfig` or `siteContentPlugin` was given
+ * @param {string} where - which of them
+ */
+export function refuseSearchOption(options, where) {
+  if (options?.search === undefined) return
+  throw new Error(
+    `${where}: the \`search\` option is retired. Whether a site has search is \`services.search\` in site.yml, ` +
+      'for every language. Remove `search` from vite.config.js.'
+  )
+}