@lexibase/rdx-next 3.2.0 → 4.1.0

package/README.md

@@ -16,6 +16,12 @@ must still be trusted project-owned content, not untrusted uploads.
 It exposes the `rdx` command used by generated projects to create their
 internal `.rdx` application and run Next.js.
 
+Run `pnpm rdx check` to validate static documentation links, heading fragments
+and local files in public/ before deployment. It reports source locations and
+exits nonzero for problems, without preparing the runtime or rendering documents.
+`rdx build` runs the same check automatically before runtime preparation and
+Next.js compilation, and stops if problems are found.
+
 Run `pnpm rdx add versioning` (or `npm exec -- rdx add versioning`) from a
 documentation project to install and activate the official optional plugin.
 The command detects the package manager, preserves config and plugin options,
@@ -25,6 +31,13 @@ Use `--package-manager npm|pnpm|yarn` to resolve ambiguous lockfiles. Dynamic
 configurations receive manual instructions and are not automatically edited.
 Installing a package with npm/pnpm/yarn alone never edits `rdx.config.ts`.
 
+Run `pnpm rdx add i18n` to activate multilingual documentation. It reuses the
+primary `lang`, asks for additional language tags and creates translation
+directories with `.gitkeep` files for empty trees. `--locales en,es-ES` supplies
+additional languages noninteractively. Existing configurations and authored
+translations are preserved; add later languages directly to `locales` and
+`locale/<folder>/docs/`. The main project creator asks only for a project name.
+
 First plugin installation follows the installed runtime: stable releases use
 `latest`, betas use `beta`, and release candidates use `rc`. Unknown prerelease
 channels require manual installation; missing tags do not fall back to another
@@ -89,7 +102,6 @@ export default defineConfig({
     authors: [{ name: 'My team', url: 'https://example.com' }],
     keywords: ['documentation', 'my-project'],
     icons: { icon: '/favicon.ico' },
-    robots: { index: true, follow: true },
     openGraph: {
       type: 'website',
       images: [{ url: '/og.png', width: 1200, height: 630, alt: 'My project' }],
@@ -111,7 +123,7 @@ production domain or force localhost. Image, favicon and manifest paths refer
 to files you create in `public/`. Nothing creates those assets automatically.
 
 Supported fields are `metadataBase` (an absolute http(s) string),
-`applicationName`, `authors`, `keywords`, `icons`, `manifest`, `robots`,
+`applicationName`, `authors`, `keywords`, `icons`, `manifest`,
 `openGraph` and `twitter`. TypeScript describes the supported nested options,
 and invalid fields fail during configuration validation. This is a portable
 subset, not an unrestricted pass-through of all Next.js metadata options.

package/bin/add-plugin.mjs

@@ -8,7 +8,18 @@ import { createRdxProject, resolveConfig } from '@lexibase/rdx-core/config'
 import spawn from 'cross-spawn'
 import { createJiti } from 'jiti'
 
-import { activateVersioning, versioningPackage } from './plugin-config.mjs'
+import {
+  activateVersioning,
+  versioningPackage,
+  activateI18n,
+  inspectI18n,
+  i18nPackage,
+} from './plugin-config.mjs'
+import {
+  askI18nLanguages,
+  initialLocales,
+  prepareLanguageFolders,
+} from './i18n-setup.mjs'
 
 const managers = new Set(['npm', 'pnpm', 'yarn'])
 const runtimeVersion = createRequire(import.meta.url)('../package.json').version
@@ -16,10 +27,18 @@ const runtimeVersion = createRequire(import.meta.url)('../package.json').version
 // Internal installer policy; channels belong to the installed runtime release,
 // not the user's docs version, invoking command or dependency range.
 export function versioningInstallRequest(version, declared) {
+  return pluginInstallRequest(version, declared, versioningPackage)
+}
+
+export function i18nInstallRequest(version, declared) {
+  return pluginInstallRequest(version, declared, i18nPackage)
+}
+
+function pluginInstallRequest(version, declared, packageName) {
   if (declared !== undefined) {
     if (typeof declared !== 'string' || !declared.trim())
       throw new Error(
-        'The declared @lexibase/rdx-versioning dependency must be a non-empty string.'
+        `The declared ${packageName} dependency must be a non-empty string.`
       )
     return { kind: 'restore' }
   }
@@ -46,26 +65,36 @@ export function versioningInstallRequest(version, declared) {
     )
   return {
     kind: 'add',
-    specifier: `${versioningPackage}@${prerelease ?? 'latest'}`,
+    specifier: `${packageName}@${prerelease ?? 'latest'}`,
   }
 }
 
 export function parseAddArguments(args) {
   const [plugin, ...rest] = args
-  if (plugin !== 'versioning')
-    throw new Error(
-      'Usage: rdx add versioning [--package-manager npm|pnpm|yarn]. Only the official versioning plugin is currently supported.'
+  const usage =
+    'Usage: rdx add versioning|i18n [--package-manager npm|pnpm|yarn]. i18n also accepts --locales en,es-ES.'
+  if (!['versioning', 'i18n'].includes(plugin)) throw new Error(usage)
+  const options = {}
+  for (let index = 0; index < rest.length; index += 2) {
+    const flag = rest[index]
+    const value = rest[index + 1]
+    if (
+      flag === '--package-manager' &&
+      managers.has(value) &&
+      !options.packageManager
     )
-  if (!rest.length) return {}
-  if (
-    rest.length === 2 &&
-    rest[0] === '--package-manager' &&
-    managers.has(rest[1])
-  )
-    return { packageManager: rest[1] }
-  throw new Error(
-    'Usage: rdx add versioning [--package-manager npm|pnpm|yarn].'
-  )
+      options.packageManager = value
+    else if (
+      plugin === 'i18n' &&
+      flag === '--locales' &&
+      value?.trim() &&
+      !value.startsWith('-') &&
+      options.locales === undefined
+    )
+      options.locales = value
+    else throw new Error(usage)
+  }
+  return options
 }
 
 async function exists(filename) {
@@ -160,7 +189,7 @@ export function installPackage(
   })
 }
 
-async function validateCandidate(filename) {
+async function validateCandidate(filename, packageName) {
   const jiti = createJiti(import.meta.url, {
     moduleCache: false,
     fsCache: false,
@@ -168,27 +197,62 @@ async function validateCandidate(filename) {
   })
   const input = await jiti.import(filename, { default: true })
   const config = resolveConfig(input)
-  // Validate paths and command registrations without running plugin setup hooks.
-  await createRdxProject(
+  // Read the official language declaration; other setup hooks run during prepare.
+  const project = await createRdxProject(
     {
       ...config,
       plugins: config.plugins.map((plugin) => ({
         ...plugin,
-        setup: undefined,
+        setup:
+          packageName === i18nPackage && plugin.name === i18nPackage
+            ? plugin.setup
+            : undefined,
       })),
     },
-    { rootDir: path.dirname(filename), command: 'prepare' }
+    { rootDir: path.dirname(filename), command: 'runtime' }
   )
   if (
-    config.plugins.filter((plugin) => plugin.name === versioningPackage)
-      .length !== 1
+    config.plugins.filter((plugin) => plugin.name === packageName).length !== 1
   )
     throw new Error(
-      'Expected exactly one official versioning plugin in the resulting configuration.'
+      `Expected exactly one ${packageName} plugin in the resulting configuration.`
     )
+  return project
 }
 
 export async function addVersioning(rootDir, options = {}) {
+  return addPlugin(rootDir, options, {
+    packageName: versioningPackage,
+    label: 'Versioning',
+    activate: activateVersioning,
+  })
+}
+
+export async function addI18n(rootDir, options = {}) {
+  return addPlugin(rootDir, options, {
+    packageName: i18nPackage,
+    label: 'i18n',
+    async activate(source) {
+      const state = inspectI18n(source)
+      if (state.configured) {
+        if (options.locales !== undefined)
+          throw new Error(
+            'i18n is already configured. Add further languages to locales in rdx.config.ts and create their locale/<folder>/docs/ directories.'
+          )
+        return source
+      }
+      const primary = Intl.getCanonicalLocales(state.lang)[0]
+      if (!primary) throw new Error('lang must be a valid language tag.')
+      const additional =
+        options.locales ?? (await (options.ask ?? askI18nLanguages)(primary))
+      if (additional === undefined) return
+      return activateI18n(source, initialLocales(primary, additional))
+    },
+  })
+}
+
+async function addPlugin(rootDir, options, definition) {
+  const { packageName, label } = definition
   const {
     install = installPackage,
     log = console.log,
@@ -209,7 +273,11 @@ export async function addVersioning(rootDir, options = {}) {
     throw new Error('rdx.config.ts must be a regular project file, not a link.')
   const original = await readFile(filename, 'utf8')
   // Refuse unsupported configurations before running the package manager.
-  const updated = activateVersioning(original)
+  const updated = await definition.activate(original)
+  if (updated === undefined) {
+    log(`${label} setup cancelled.`)
+    return { changed: false, cancelled: true }
+  }
   const pkg = JSON.parse(
     await readFile(path.join(rootDir, 'package.json'), 'utf8')
   )
@@ -220,11 +288,10 @@ export async function addVersioning(rootDir, options = {}) {
     options.packageManager
   )
   const declared =
-    pkg.dependencies?.[versioningPackage] ??
-    pkg.devDependencies?.[versioningPackage]
+    pkg.dependencies?.[packageName] ?? pkg.devDependencies?.[packageName]
   let installed = false
   try {
-    createRequire(path.join(rootDir, 'package.json')).resolve(versioningPackage)
+    createRequire(path.join(rootDir, 'package.json')).resolve(packageName)
     installed = true
   } catch (error) {
     // The official package exposes ESM imports only. require.resolve can find
@@ -234,21 +301,27 @@ export async function addVersioning(rootDir, options = {}) {
       throw error
   }
   if (!declared || !installed) {
-    const request = versioningInstallRequest(runtimeVersion, declared)
+    const request = pluginInstallRequest(runtimeVersion, declared, packageName)
     log(
       request.kind === 'restore'
-        ? `Restoring the declared ${versioningPackage} dependency with ${manager}...`
+        ? `Restoring the declared ${packageName} dependency with ${manager}...`
         : `Installing ${request.specifier} with ${manager}...`
     )
     await install(manager, rootDir, env, request)
-  } else
-    log(`${versioningPackage} is already installed; preserving its version.`)
+  } else log(`${packageName} is already installed; preserving its version.`)
 
   const temporary = path.join(rootDir, `rdx.config.add-${randomUUID()}.ts`)
+  let rollbackFolders
+  let committed = false
   try {
     await writeFile(temporary, updated, { flag: 'wx', mode: info.mode })
     try {
-      await validateCandidate(temporary)
+      const project = await validateCandidate(temporary, packageName)
+      if (project.localization)
+        rollbackFolders = await prepareLanguageFolders(
+          rootDir,
+          project.localization
+        )
     } catch (error) {
       throw new Error(
         `Plugin configuration validation failed: ${error.message}. rdx.config.ts was not changed. Installed dependencies were kept; fix the error and retry.`
@@ -265,10 +338,13 @@ export async function addVersioning(rootDir, options = {}) {
       )
     if (updated !== original) {
       await rename(temporary, filename)
-      log('Versioning activated in rdx.config.ts.')
+      committed = true
+      log(`${label} activated in rdx.config.ts.`)
     } else
-      log('Versioning is already configured; no configuration changes needed.')
+      log(`${label} is already configured; no configuration changes needed.`)
+    committed = true
   } finally {
+    if (!committed) await rollbackFolders?.()
     await unlink(temporary).catch((error) => {
       if (error.code !== 'ENOENT') throw error
     })

package/bin/cli.mjs

@@ -11,6 +11,7 @@ import { createJiti } from 'jiti'
 import postcssConfig from '../postcss.config.mjs'
 import { preparePublicAssets } from './public-assets.mjs'
 import { prepareProjectStyles } from './project-styles.mjs'
+import { prepareLocaleRoutes } from './locale-routes.mjs'
 
 export async function runRdxCli({ templateDir } = {}) {
   const supportedCommands = new Set(['dev', 'build', 'start'])
@@ -25,7 +26,7 @@ export async function runRdxCli({ templateDir } = {}) {
     templateDir ?? path.join(packageRoot, 'templates', 'runtime')
   const runtimeDirectory = path.join(projectRoot, '.rdx')
 
-  async function prepareRuntime() {
+  async function prepareRuntime(project) {
     await mkdir(runtimeDirectory, { recursive: true })
     await preparePublicAssets(projectRoot, runtimeDirectory)
     await cp(runtimeTemplate, runtimeDirectory, {
@@ -33,6 +34,7 @@ export async function runRdxCli({ templateDir } = {}) {
       recursive: true,
     })
     await prepareProjectStyles(projectRoot, runtimeDirectory)
+    await prepareLocaleRoutes(project, runtimeDirectory, runtimeTemplate)
     // Resolve in Node before Next processes this file: UI may be transitive,
     // and native Tailwind plugins must stay outside the Turbopack module graph.
     const resolvePlugin = createRequire(import.meta.url)
@@ -50,19 +52,61 @@ export async function runRdxCli({ templateDir } = {}) {
 
   async function main() {
     if (!command || command === 'help' || command === '--help') {
-      console.log('Usage: rdx <dev|build|start|prepare|add|plugin-command>')
+      console.log(
+        'Usage: rdx <dev|build|start|prepare|check|add|plugin-command>'
+      )
+      console.log(
+        '  rdx check: validate documentation links, sections and local assets'
+      )
       console.log('  rdx add versioning [--package-manager npm|pnpm|yarn]')
+      console.log(
+        '  rdx add i18n [--locales en,es-ES] [--package-manager npm|pnpm|yarn]'
+      )
       console.log(
         'Plugin commands are registered through plugins in rdx.config.ts.'
       )
       return
     }
 
+    if (command === 'check') {
+      if (
+        commandArgs.length === 1 &&
+        ['--help', '-h'].includes(commandArgs[0])
+      ) {
+        console.log(
+          'Usage: rdx check\nValidate static MDX links, section anchors and local public/ files without building the site.'
+        )
+        return
+      }
+      if (commandArgs.length) throw new Error('Usage: rdx check')
+    }
+
     if (command === 'add') {
-      const { addVersioning, parseAddArguments } =
+      if (
+        (commandArgs.length === 1 &&
+          ['--help', '-h'].includes(commandArgs[0])) ||
+        (commandArgs.length === 2 &&
+          ['versioning', 'i18n'].includes(commandArgs[0]) &&
+          ['--help', '-h'].includes(commandArgs[1]))
+      ) {
+        console.log(
+          'Usage: rdx add versioning|i18n [--package-manager npm|pnpm|yarn]'
+        )
+        console.log(
+          '  i18n: reuse lang and ask for additional languages, or pass --locales en,es-ES.'
+        )
+        console.log(
+          '  Existing i18n languages are edited in rdx.config.ts and locale/<folder>/docs/.'
+        )
+        return
+      }
+      const { addVersioning, addI18n, parseAddArguments } =
         await import('./add-plugin.mjs')
       const options = parseAddArguments(commandArgs)
-      await addVersioning(projectRoot, options)
+      const result = await (
+        commandArgs[0] === 'i18n' ? addI18n : addVersioning
+      )(projectRoot, options)
+      if (result.cancelled) return
       command = 'prepare'
     }
 
@@ -96,8 +140,20 @@ export async function runRdxCli({ templateDir } = {}) {
       rootDir: projectRoot,
       command,
     })
+    if (command === 'check' || command === 'build') {
+      const { checkDocumentation, formatDocumentationCheck } =
+        await import('@lexibase/rdx-core/check')
+      const report = checkDocumentation(project)
+      const output = formatDocumentationCheck(report)
+      if (report.diagnostics.length) {
+        console.error(output)
+        process.exitCode = 1
+        return
+      } else console.log(output)
+      if (command === 'check') return
+    }
     if (command === 'prepare') {
-      await prepareRuntime()
+      await prepareRuntime(project)
       console.log('RDX runtime prepared in .rdx/')
       return
     }
@@ -107,7 +163,7 @@ export async function runRdxCli({ templateDir } = {}) {
       )
       if (!pluginCommand)
         throw new Error(
-          `Unknown command "${command}". Available: dev, build, start, prepare, add${project.commands.map((entry) => `, ${entry.name}`).join('')}. Install and configure the plugin that provides this command.`
+          `Unknown command "${command}". Available: dev, build, start, prepare, check, add${project.commands.map((entry) => `, ${entry.name}`).join('')}. Install and configure the plugin that provides this command.`
         )
       await pluginCommand.run({
         rootDir: projectRoot,
@@ -118,7 +174,7 @@ export async function runRdxCli({ templateDir } = {}) {
       return
     }
 
-    await prepareRuntime()
+    await prepareRuntime(project)
     const projectRequire = createRequire(path.join(projectRoot, 'package.json'))
     const nextCli = projectRequire.resolve('next/dist/bin/next')
     const child = spawn(

package/bin/i18n-setup.mjs

@@ -0,0 +1,115 @@
+import {
+  lstat,
+  mkdir,
+  realpath,
+  rmdir,
+  writeFile,
+  readFile,
+  unlink,
+} from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+
+import { normalizeLocalization } from '@lexibase/rdx-core/config'
+
+function languageLabel(code) {
+  try {
+    const label = new Intl.DisplayNames([code], { type: 'language' }).of(code)
+    return label[0].toLocaleUpperCase(code) + label.slice(1)
+  } catch {
+    // Valid tags with extensions need not have a display name in ICU.
+    return code
+  }
+}
+
+/** Additional language tags; the existing lang always remains primary. */
+export function initialLocales(primary, additional) {
+  const lang = Intl.getCanonicalLocales(primary)[0]
+  if (!lang) throw new Error('lang must be a valid language tag.')
+  if (typeof additional !== 'string' || !additional.trim())
+    throw new Error('Enter at least one additional language, e.g. en, es-ES.')
+  const codes = additional.split(',').map((value) => {
+    const code = Intl.getCanonicalLocales(value.trim())[0]
+    if (!code) throw new Error('Enter language tags separated by commas.')
+    return code
+  })
+  const locales = [lang, ...codes.filter((code) => code !== lang)].map(
+    (code) => ({
+      code,
+      label: languageLabel(code),
+    })
+  )
+  // Use the same validation as manual configuration, including duplicates.
+  normalizeLocalization({ locales }, lang)
+  return locales
+}
+
+export async function askI18nLanguages(primary) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY)
+    throw new Error(
+      'Interactive language setup needs a terminal. Use rdx add i18n --locales en,es-ES (additional languages; lang stays primary).'
+    )
+  const { default: prompts } = await import('prompts')
+  const response = await prompts({
+    type: 'text',
+    name: 'languages',
+    message: `Additional languages (primary: ${primary}; e.g. en, es-ES)`,
+    validate(value) {
+      try {
+        initialLocales(primary, value)
+        return true
+      } catch (error) {
+        return error.message
+      }
+    },
+  })
+  return response.languages
+}
+
+/** Create only empty translation directories; never copy or replace documents. */
+export async function prepareLanguageFolders(rootDir, localization) {
+  const root = await realpath(rootDir)
+  const created = []
+  const markers = []
+  async function rollback() {
+    for (const marker of markers)
+      if ((await readFile(marker, 'utf8').catch(() => undefined)) === '')
+        await unlink(marker).catch((error) => {
+          if (error.code !== 'ENOENT') throw error
+        })
+    for (const directory of [...created].reverse())
+      await rmdir(directory).catch((error) => {
+        // A user may have started writing while installation was running.
+        if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(error.code)) throw error
+      })
+  }
+  try {
+    for (const locale of localization.locales) {
+      if (!locale.folder) continue
+      let directory = root
+      for (const part of ['locale', locale.folder, 'docs']) {
+        directory = path.join(directory, part)
+        try {
+          await mkdir(directory)
+          created.push(directory)
+        } catch (error) {
+          if (error.code !== 'EEXIST') throw error
+        }
+        const info = await lstat(directory)
+        if (!info.isDirectory() || info.isSymbolicLink())
+          throw new Error(
+            `Translation folders must be regular project directories: ${directory}`
+          )
+      }
+      if (created.includes(directory)) {
+        const marker = path.join(directory, '.gitkeep')
+        await writeFile(marker, '', { flag: 'wx' })
+        markers.push(marker)
+      }
+    }
+  } catch (error) {
+    await rollback()
+    throw error
+  }
+  return rollback
+}

package/bin/locale-routes.mjs

@@ -0,0 +1,138 @@
+import { lstat, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+const defaultFiles = [
+  'layout.tsx',
+  'page.tsx',
+  'not-found.tsx',
+  'docs/[[...slug]]/page.tsx',
+]
+const generated = [
+  ...defaultFiles.map((file) => `app/(rdx-default)/${file}`),
+  'app/(rdx-default)/[...notFound]/page.tsx',
+  'app/(rdx-locales)/[locale]/layout.tsx',
+  'app/(rdx-locales)/[locale]/not-found.tsx',
+  'app/(rdx-locales)/[locale]/docs/[[...slug]]/page.tsx',
+  'app/(rdx-locales)/[locale]/rdx-search/[source]/route.ts',
+]
+
+/** Root layouts keep HTML language correct on the server, without middleware. */
+export async function prepareLocaleRoutes(project, runtime, template) {
+  async function safe(file) {
+    const parts = file.split('/')
+    let current = runtime
+    for (const segment of parts) {
+      current = path.join(current, segment)
+      try {
+        if ((await lstat(current)).isSymbolicLink())
+          throw new Error(
+            `Generated locale routes must not contain links: ${current}`
+          )
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error
+      }
+    }
+    return current
+  }
+  const marker = await safe('.rdx-localization.json')
+  let owned = false
+  try {
+    owned = JSON.parse(await readFile(marker, 'utf8')).version === 1
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error
+  }
+  if (!project.localization) {
+    if (owned) {
+      for (const file of generated) await rm(await safe(file), { force: true })
+      await rm(marker)
+    }
+    return
+  }
+  async function emit(file, content) {
+    const target = await safe(file)
+    if (!owned) {
+      try {
+        await lstat(target)
+        throw new Error(
+          `Conflicting generated locale route: ${target}. Remove the old .rdx/ runtime and prepare again.`
+        )
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error
+      }
+    }
+    await mkdir(path.dirname(target), { recursive: true })
+    await writeFile(target, content)
+  }
+  const layout = await readFile(path.join(template, 'app/layout.tsx'), 'utf8')
+  const provider = layout.match(/from '([^']+\/runtime)'/)[1]
+  for (const file of defaultFiles) {
+    const text = await readFile(path.join(template, 'app', file), 'utf8')
+    await emit(
+      `app/(rdx-default)/${file}`,
+      text
+        .replace(/from '(\.\.\/[^']*rdx-project)'/g, "from '../$1'")
+        .replace("'./globals.css'", "'../globals.css'")
+    )
+  }
+  await emit(
+    'app/(rdx-default)/[...notFound]/page.tsx',
+    `import { notFound } from 'next/navigation'\nexport default function Missing() { notFound() }\n`
+  )
+  await emit(
+    'app/(rdx-locales)/[locale]/layout.tsx',
+    `import { RdxLayout, getRdxMetadata, getLocalizedProject } from '${provider}'
+import { getProject } from '../../../rdx-project'
+import '../../globals.css'
+export async function generateStaticParams() { return (await getProject()).localization!.locales.map(locale => ({ locale: locale.path })) }
+export const dynamicParams = false
+async function configuration(params: Promise<{ locale: string }>) {
+  const project = await getProject()
+  const { locale } = await params
+  return project.localization!.locales.some(entry => entry.path === locale) ? getLocalizedProject(project, locale).config : project.config
+}
+export async function generateMetadata({ params }: { params: Promise<{ locale: string }> }) { return getRdxMetadata(await configuration(params)) }
+export default async function Layout({ children, params }: { children: React.ReactNode, params: Promise<{ locale: string }> }) {
+  return <RdxLayout config={await configuration(params)} bodyClassName="antialiased">{children}</RdxLayout>
+}
+`
+  )
+  await emit(
+    'app/(rdx-locales)/[locale]/not-found.tsx',
+    `import { NotFoundPage } from '${provider}'
+import { getProject } from '../../../rdx-project'
+export default async function Missing() { return <NotFoundPage project={await getProject()} /> }
+`
+  )
+  await emit(
+    'app/(rdx-locales)/[locale]/docs/[[...slug]]/page.tsx',
+    `import { DocsPage, getDocumentMetadata, getProjectDocsPaths, getLocalizedProject } from '${provider}'
+import { notFound } from 'next/navigation'
+import { getProject } from '../../../../../rdx-project'
+type Params = { locale: string, slug?: string[] }
+async function selected(locale: string) {
+  const project = await getProject()
+  if (!project.localization!.locales.some(entry => entry.path === locale)) notFound()
+  return getLocalizedProject(project, locale)
+}
+export async function generateStaticParams({ params }: { params: { locale: string } }) { return getProjectDocsPaths(await selected(params.locale)).map(slug => ({ slug: slug.split('/') })) }
+export async function generateMetadata({ params }: { params: Promise<Params> }) { const { locale, slug } = await params; return getDocumentMetadata({ project: await selected(locale), slug }) }
+export default async function Page({ params }: { params: Promise<Params> }) { const { locale, slug } = await params; return <DocsPage project={await selected(locale)} slug={slug} /> }
+`
+  )
+  await emit(
+    'app/(rdx-locales)/[locale]/rdx-search/[source]/route.ts',
+    `import { getSearchResponse, getSearchSources, getLocalizedProject } from '${provider}'
+import { getProject } from '../../../../../rdx-project'
+export const dynamic = 'force-static'
+export const dynamicParams = false
+export async function generateStaticParams() {
+  const project = await getProject()
+  return project.localization!.locales.flatMap(locale => getSearchSources(getLocalizedProject(project, locale.path)).map(source => ({ locale: locale.path, ...source })))
+}
+export async function GET(_request: Request, { params }: { params: Promise<{ locale: string, source: string }> }) { const { locale, source } = await params; return getSearchResponse(getLocalizedProject(await getProject(), locale), source) }
+`
+  )
+  await writeFile(marker, JSON.stringify({ version: 1 }) + '\n')
+  for (const file of defaultFiles)
+    await rm(await safe(`app/${file}`), { force: true })
+}