@lexibase/rdx-next 4.0.0 → 4.1.0

package/README.md

@@ -19,6 +19,8 @@ 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.
@@ -29,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

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)
@@ -57,6 +59,9 @@ export async function runRdxCli({ templateDir } = {}) {
         '  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.'
       )
@@ -77,10 +82,31 @@ export async function runRdxCli({ templateDir } = {}) {
     }
 
     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'
     }
 
@@ -114,7 +140,7 @@ export async function runRdxCli({ templateDir } = {}) {
       rootDir: projectRoot,
       command,
     })
-    if (command === 'check') {
+    if (command === 'check' || command === 'build') {
       const { checkDocumentation, formatDocumentationCheck } =
         await import('@lexibase/rdx-core/check')
       const report = checkDocumentation(project)
@@ -122,11 +148,12 @@ export async function runRdxCli({ templateDir } = {}) {
       if (report.diagnostics.length) {
         console.error(output)
         process.exitCode = 1
+        return
       } else console.log(output)
-      return
+      if (command === 'check') return
     }
     if (command === 'prepare') {
-      await prepareRuntime()
+      await prepareRuntime(project)
       console.log('RDX runtime prepared in .rdx/')
       return
     }
@@ -147,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 })
+}

package/bin/plugin-config.mjs

@@ -1,7 +1,29 @@
 import ts from 'typescript'
 
 export const versioningPackage = '@lexibase/rdx-versioning'
-const manual = `Cannot safely edit rdx.config.ts. Add "import { versioning } from '${versioningPackage}'" and versioning() to plugins manually, then run rdx prepare.`
+export const i18nPackage = '@lexibase/rdx-i18n'
+const versioning = {
+  packageName: versioningPackage,
+  name: 'versioning',
+  label: 'Versioning',
+}
+const localization = { packageName: i18nPackage, name: 'i18n', label: 'i18n' }
+
+export function activateVersioning(source) {
+  return editPluginConfig(source, versioning)
+}
+
+export function inspectI18n(source) {
+  return editPluginConfig(source, localization, '', true)
+}
+
+export function activateI18n(source, locales) {
+  return editPluginConfig(
+    source,
+    localization,
+    JSON.stringify({ locales }, null, 2)
+  )
+}
 
 function unwrap(node) {
   while (
@@ -14,7 +36,9 @@ function unwrap(node) {
 }
 
 // Edit only known literal shapes; never print/reconstruct the user's entire file.
-export function activateVersioning(source) {
+function editPluginConfig(source, plugin, argument = '', inspect = false) {
+  const { packageName, name: pluginName, label } = plugin
+  const manual = `Cannot safely edit rdx.config.ts. Add "import { ${pluginName} } from '${packageName}'" and ${pluginName}(${pluginName === 'i18n' ? '{ locales: [...] }' : ''}) to plugins manually, then run rdx prepare.`
   const file = ts.createSourceFile(
     'rdx.config.ts',
     source,
@@ -44,7 +68,7 @@ export function activateVersioning(source) {
           imported === 'defineConfig'
         )
           definitions.add(specifier.name.text)
-        if (name === versioningPackage && imported === 'versioning') {
+        if (name === packageName && imported === pluginName) {
           if (factory) throw new Error(manual)
           factory = specifier.name.text
         }
@@ -52,10 +76,10 @@ export function activateVersioning(source) {
     } else if (
       bindings &&
       ts.isNamespaceImport(bindings) &&
-      name === versioningPackage
+      name === packageName
     ) {
       if (factory) throw new Error(manual)
-      factory = `${bindings.name.text}.versioning`
+      factory = `${bindings.name.text}.${pluginName}`
     }
   }
   const exports = file.statements.filter(ts.isExportAssignment)
@@ -100,9 +124,18 @@ export function activateVersioning(source) {
     )
     if (matches.length > 1)
       throw new Error(
-        'Versioning is configured more than once. Remove the duplicate plugin before retrying.'
+        `${label} is configured more than once. Remove the duplicate plugin before retrying.`
       )
-    if (matches.length === 1) return source
+    if (matches.length === 1) return inspect ? { configured: true } : source
+  }
+  if (inspect) {
+    const languages = properties.filter((entry) => entry.name.text === 'lang')
+    if (languages.length > 1) throw new Error(manual)
+    const language = languages.length
+      ? unwrap(languages[0].initializer)
+      : undefined
+    if (language && !ts.isStringLiteral(language)) throw new Error(manual)
+    return { configured: false, lang: language?.text ?? 'en' }
   }
   const newline = source.includes('\r\n') ? '\r\n' : '\n'
   const edits = []
@@ -113,11 +146,12 @@ export function activateVersioning(source) {
       ts.forEachChild(node, visit)
     }
     visit(file)
-    factory = 'versioning'
+    factory = pluginName
     let suffix = 1
-    while (identifiers.has(factory)) factory = `rdxVersioning${suffix++}`
+    const alias = `rdx${pluginName[0].toUpperCase()}${pluginName.slice(1)}`
+    while (identifiers.has(factory)) factory = `${alias}${suffix++}`
     const specifier =
-      factory === 'versioning' ? 'versioning' : `versioning as ${factory}`
+      factory === pluginName ? pluginName : `${pluginName} as ${factory}`
     let position = imports.length
       ? imports.at(-1).end
       : file.statements[0].getStart(file)
@@ -133,7 +167,7 @@ export function activateVersioning(source) {
     }
     edits.push({
       position,
-      text: `${newline}import { ${specifier} } from '${versioningPackage}'${newline}`,
+      text: `${newline}import { ${specifier} } from '${packageName}'${newline}`,
     })
   }
   if (plugins) {
@@ -142,14 +176,14 @@ export function activateVersioning(source) {
       : plugins.getStart(file) + 1
     edits.push({
       position,
-      text: `${plugins.elements.length ? ',' : ''} ${factory}()`,
+      text: `${plugins.elements.length ? ',' : ''} ${factory}(${argument.replaceAll('\n', newline)})`,
     })
   } else {
     if (properties.length && !properties.hasTrailingComma)
       edits.push({ position: properties.at(-1).end, text: ',' })
     edits.push({
       position: config.end - 1,
-      text: `${newline}  plugins: [${factory}()],${newline}`,
+      text: `${newline}  plugins: [${factory}(${argument.replaceAll('\n', newline)})],${newline}`,
     })
   }
   for (const edit of edits.sort((a, b) => b.position - a.position))

package/config.mjs

@@ -2,7 +2,11 @@ import { readdir, realpath, stat } from 'node:fs/promises'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 
-import { createRdxProject, resolveProjectPath } from '@lexibase/rdx-core/config'
+import {
+  createRdxProject,
+  resolveProjectPath,
+  getContentSources,
+} from '@lexibase/rdx-core/config'
 import { createJiti } from 'jiti'
 
 /** Include the project and the real Next.js installation in Turbopack's root. */
@@ -77,7 +81,7 @@ export async function getRdxTracingConfig({ rootDir, appDir = rootDir }) {
   const project = await createRdxProject(input, { rootDir })
   const files = (
     await Promise.all(
-      project.sources
+      getContentSources(project)
         .filter((source) => source.redirectTo === undefined)
         .map((source) =>
           contentFiles(
@@ -102,11 +106,28 @@ export async function getRdxTracingConfig({ rootDir, appDir = rootDir }) {
   }
   const redirects = project.sources
     .filter((source) => source.redirectTo !== undefined)
-    .map((source) => ({
-      source: `/docs/${source.routePrefix}/:path*`,
-      destination: `/docs/${source.redirectTo}/:path*`,
+    .flatMap((source) =>
+      [
+        '/docs',
+        ...(project.localization?.locales.map(
+          (locale) => `/${locale.path}/docs`
+        ) ?? []),
+      ].map((base) => ({
+        source: `${base}/${source.routePrefix}/:path*`,
+        destination: `${base}/${source.redirectTo}/:path*`,
+        permanent: true,
+      }))
+    )
+  if (project.localization) {
+    const primary = project.localization.locales.find(
+      (locale) => locale.code === project.localization.defaultLocale
+    )
+    redirects.push({
+      source: '/docs/:path*',
+      destination: `/${primary.path}/docs/:path*`,
       permanent: true,
-    }))
+    })
+  }
   return {
     ...(redirects.length ? { redirects: async () => redirects } : {}),
     outputFileTracingIncludes: {

package/dist/runtime/index.d.ts

@@ -1,7 +1,7 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 import { RdxProject, RDXConfig, RdxContentSource, RdxDocPage } from '@lexibase/rdx-types';
-export { createRdxProject, getProjectDocsPaths } from '@lexibase/rdx-core';
+export { createRdxProject, getLocalizedProject, getProjectDocsPaths } from '@lexibase/rdx-core';
 import { MetadataRoute, Metadata } from 'next';
 
 declare function getSearchSources(project: RdxProject): {

package/dist/runtime/index.js

@@ -1,11 +1,17 @@
 // src/runtime/index.tsx
 import {
-  getDocument as getDocument2,
+  getDocument as getDocument3,
   getDocsPaths,
-  getSourceOptions as getSourceOptions3,
-  resolveDocsRoute as resolveDocsRoute2
+  getSourceOptions as getSourceOptions4,
+  resolveDocsRoute as resolveDocsRoute2,
+  getLocalizedProject as getLocalizedProject2,
+  getDocsHref as getDocsHref3,
+  getLanguageLinks,
+  isFallbackPage as isFallbackPage3
 } from "@lexibase/rdx-core";
 import { Button } from "@lexibase/rdx-ui/components/button";
+import { Callout } from "@lexibase/rdx-ui/components/callout";
+import { LanguageDropdown } from "@lexibase/rdx-ui/components/language-dropdown";
 import { DocsSidebar } from "@lexibase/rdx-ui/components/docs-sidebar";
 import { DocsToc } from "@lexibase/rdx-ui/components/docs-toc";
 import { DocsPageTransition } from "@lexibase/rdx-ui/components/docs-page-transition";
@@ -19,6 +25,7 @@ import { getMessages, formatMessage } from "@lexibase/rdx-ui/lib/i18n";
 import { LocaleProvider } from "@lexibase/rdx-ui/providers/locale-provider";
 import { Navbar } from "@lexibase/rdx-ui/components/navbar";
 import { NotFound } from "@lexibase/rdx-ui/components/not-found";
+import { LocalizedNotFound } from "@lexibase/rdx-ui/components/localized-not-found";
 import {
   VersionDropdown
 } from "@lexibase/rdx-ui/components/version-dropdown";
@@ -54,10 +61,19 @@ function compileDocumentation(source, components, links) {
 }
 
 // src/runtime/index.tsx
-import { createRdxProject, getProjectDocsPaths } from "@lexibase/rdx-core";
+import {
+  createRdxProject,
+  getProjectDocsPaths,
+  getLocalizedProject as getLocalizedProject3
+} from "@lexibase/rdx-core";
 
 // src/runtime/search.ts
-import { getDocsIndex, getDocument, getSourceOptions } from "@lexibase/rdx-core";
+import {
+  getDocsIndex,
+  getDocument,
+  getSourceOptions,
+  getDocsHref
+} from "@lexibase/rdx-core";
 import { buildSearchIndex } from "@lexibase/rdx-core/search";
 function getSearchSources(project) {
   return project.config.search ? project.sources.filter((source) => source.redirectTo === void 0).map((source) => ({ source: source.routePrefix || "_" })) : [];
@@ -70,17 +86,16 @@ function getSearchResponse(project, key) {
     (entry) => entry.redirectTo === void 0 && (entry.routePrefix || "_") === key
   );
   if (!source) return new Response(null, { status: 404, headers });
-  const options = getSourceOptions(project, source);
+  if (source.fallbackOnly)
+    return Response.json(buildSearchIndex([]), { headers });
+  const { docsDir } = getSourceOptions(project, source);
+  const options = { docsDir };
   const documents = getDocsIndex(options).flatMap(
     (category) => category.pages.map((page) => ({
       title: page.title,
       description: page.description,
       category: category.title,
-      href: [
-        "/docs",
-        source.routePrefix,
-        page.slug.split("/").map(encodeURIComponent).join("/")
-      ].filter(Boolean).join("/"),
+      href: getDocsHref(project, source, page.slug),
       content: getDocument(page.slug, options)?.content ?? ""
     }))
   );
@@ -88,7 +103,12 @@ function getSearchResponse(project, key) {
 }
 
 // src/runtime/indexing.ts
-import { getDocsIndex as getDocsIndex2, getSourceOptions as getSourceOptions2 } from "@lexibase/rdx-core";
+import {
+  getDocsIndex as getDocsIndex2,
+  getSourceOptions as getSourceOptions2,
+  getContentSources,
+  isFallbackPage
+} from "@lexibase/rdx-core";
 function getSourceRobots(project, source) {
   const published = project.sources.some(
     (entry) => entry.id !== "current" && entry.redirectTo === void 0 && entry.badge !== "Archived"
@@ -107,7 +127,7 @@ function getRdxRobots(config) {
 }
 function getRdxSitemap(project, {
   documentPath = (source, page) => [
-    "/docs",
+    source.basePath ?? "/docs",
     source.routePrefix,
     page.slug.split("/").map(encodeURIComponent).join("/")
   ].filter(Boolean).join("/")
@@ -116,10 +136,11 @@ function getRdxSitemap(project, {
   if (!base) return [];
   const urls = /* @__PURE__ */ new Set();
   if (project.config.homepage?.enabled) urls.add(new URL("/", base).href);
-  for (const source of project.sources) {
+  for (const source of getContentSources(project)) {
     if (!getSourceRobots(project, source).index) continue;
     for (const category of getDocsIndex2(getSourceOptions2(project, source))) {
       for (const page of category.pages) {
+        if (isFallbackPage(project, source, page.sourcePath)) continue;
         urls.add(new URL(documentPath(source, page), base).href);
       }
     }
@@ -128,21 +149,67 @@ function getRdxSitemap(project, {
 }
 
 // src/runtime/metadata.ts
-import { resolveDocsRoute } from "@lexibase/rdx-core";
+import {
+  resolveDocsRoute,
+  getLocalizedProject,
+  getDocsHref as getDocsHref2,
+  isFallbackPage as isFallbackPage2,
+  getDocument as getDocument2,
+  getSourceOptions as getSourceOptions3
+} from "@lexibase/rdx-core";
 import { notFound } from "next/navigation";
 function getDocumentMetadata({
   project,
   slug
 }) {
+  if (project.localization && !project.locale)
+    return { robots: { index: false, follow: true } };
   const route = resolveDocsRoute(project, slug);
   if (route.source.redirectTo !== void 0)
     return { robots: getSourceRobots(project, route.source) };
   if (!route.slug) return { robots: { index: false, follow: true } };
   if (!route.document) notFound();
   const page = route.categories.flatMap((category) => category.pages).find((page2) => page2.slug === route.slug);
+  const fallback = isFallbackPage2(project, route.source, page.sourcePath);
+  const primary = project.localization?.locales.find(
+    (locale) => locale.code === project.localization.defaultLocale
+  );
+  const canonicalProject = fallback ? getLocalizedProject(project, primary.path) : project;
+  const base = project.config.metadata.metadataBase;
+  const languages = project.localization && base ? Object.fromEntries(
+    project.localization.locales.flatMap((locale) => {
+      const view = getLocalizedProject(project, locale.path);
+      const source = view.sources.find(
+        (entry) => entry.id === route.source.id
+      );
+      return !source.fallbackOnly && getDocument2(page.slug, {
+        docsDir: getSourceOptions3(view, source).docsDir
+      }) ? [
+        [
+          locale.code,
+          new URL(getDocsHref2(view, source, page.slug), base).href
+        ]
+      ] : [];
+    })
+  ) : void 0;
   return {
     ...getPageMetadata(project.config, page),
-    robots: getSourceRobots(project, route.source)
+    robots: fallback ? { index: false, follow: true } : getSourceRobots(project, route.source),
+    ...project.localization && base ? {
+      alternates: {
+        canonical: new URL(
+          getDocsHref2(
+            canonicalProject,
+            canonicalProject.sources.find(
+              (entry) => entry.id === route.source.id
+            ),
+            page.slug
+          ),
+          base
+        ).href,
+        ...fallback ? {} : { languages }
+      }
+    } : {}
   };
 }
 function getPageMetadata(config, page) {
@@ -211,13 +278,13 @@ function RdxHeader({
   const messages = getMessages(config.lang);
   const { source, slug: currentSlug } = resolveDocsRoute2(project, slug);
   const options = project.sources.filter((edition) => edition.redirectTo === void 0).map((edition) => {
-    const docs = getSourceOptions3(project, edition);
-    const destination = currentSlug && getDocument2(currentSlug, docs) ? currentSlug : getDocsPaths(docs)[0];
+    const docs = getSourceOptions4(project, edition);
+    const destination = currentSlug && getDocument3(currentSlug, docs) ? currentSlug : getDocsPaths(docs)[0];
     return {
       id: edition.id,
       label: edition.id === "current" ? messages.current : formatMessage(messages.version, { version: edition.label }),
       kind: edition.id === "current" ? "live" : edition.badge === "Archived" ? "archived" : "version",
-      href: ["/docs", edition.routePrefix, destination].filter(Boolean).join("/")
+      href: getDocsHref3(project, edition, destination)
     };
   });
   const BrandLogo = config.navbar?.logo ?? Logo;
@@ -229,14 +296,23 @@ function RdxHeader({
       search: config.search ? /* @__PURE__ */ jsx(
         DocsSearch,
         {
-          indexUrl: `/rdx-search/${encodeURIComponent(source.routePrefix || "_")}`,
+          indexUrl: `${project.locale ? `/${project.locale.path}` : ""}/rdx-search/${encodeURIComponent(source.routePrefix || "_")}`,
           version: source.id === "current" ? messages.current : formatMessage(messages.version, { version: source.label })
         }
       ) : void 0,
       siteTitle: config.metadata.applicationName,
       logo: /* @__PURE__ */ jsx(BrandLogo, { className: "size-5" }),
-      homeHref: config.homepage?.enabled ? "/" : "/docs",
-      docsHref: ["/docs", source.routePrefix].filter(Boolean).join("/"),
+      homeHref: config.homepage?.enabled ? "/" : getDocsHref3(project),
+      docsHref: getDocsHref3(project, source),
+      languageMenu: project.localization ? /* @__PURE__ */ jsx(
+        LanguageDropdown,
+        {
+          lang: config.lang,
+          current: project.locale?.code ?? project.localization.defaultLocale,
+          options: getLanguageLinks(project, source, currentSlug),
+          contributionUrl: project.localization.contributionUrl
+        }
+      ) : void 0,
       versionMenu: project.sources.length > 1 ? /* @__PURE__ */ jsx(VersionDropdown, { options, currentId: source.id }) : void 0,
       github: config.navbar?.actions?.github,
       showToggleMode: config.navbar?.actions?.showToggleMode
@@ -245,7 +321,7 @@ function RdxHeader({
 }
 function HomePage({ project }) {
   const { config } = project;
-  if (!config.homepage?.enabled) redirect("/docs");
+  if (!config.homepage?.enabled) redirect(getDocsHref3(project));
   const homepage = config.homepage;
   const CustomHome = homepage.component;
   const BrandLogo = config.navbar?.logo ?? Logo;
@@ -271,6 +347,25 @@ function HomePage({ project }) {
   ] });
 }
 function NotFoundPage({ project }) {
+  if (project.localization) {
+    const { config, localization } = project;
+    const BrandLogo = config.navbar?.logo ?? Logo;
+    return /* @__PURE__ */ jsx(
+      LocalizedNotFound,
+      {
+        locales: localization.locales,
+        defaultLocale: localization.defaultLocale,
+        homepage: !!config.homepage?.enabled,
+        brand: {
+          title: config.navbar?.title,
+          siteTitle: config.metadata.applicationName,
+          github: config.navbar?.actions?.github,
+          showToggleMode: config.navbar?.actions?.showToggleMode,
+          logo: /* @__PURE__ */ jsx(BrandLogo, { className: "size-5" })
+        }
+      }
+    );
+  }
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx(RdxHeader, { project }),
     /* @__PURE__ */ jsx(NotFound, { lang: project.config.lang })
@@ -280,6 +375,8 @@ async function DocsPage({
   slug,
   project
 }) {
+  if (project.localization && !project.locale)
+    permanentRedirect(getDocsHref3(project, project.sources[0], slug?.join("/")));
   const messages = getMessages(project.config.lang);
   const {
     source,
@@ -289,11 +386,13 @@ async function DocsPage({
   } = resolveDocsRoute2(project, slug);
   if (source.redirectTo !== void 0)
     permanentRedirect(
-      [
-        "/docs",
-        source.redirectTo,
-        ...slug?.slice(1).map(encodeURIComponent) ?? []
-      ].join("/")
+      getDocsHref3(
+        project,
+        project.sources.find(
+          (entry) => entry.routePrefix === source.redirectTo
+        ),
+        slug?.slice(1).join("/")
+      )
     );
   if (!currentSlug)
     return /* @__PURE__ */ jsxs(Fragment, { children: [
@@ -304,19 +403,32 @@ async function DocsPage({
       ] })
     ] });
   if (!document) notFound2();
+  const fallback = isFallbackPage3(project, source, document.sourcePath);
+  const primaryLocale = (source.localization ?? project.localization)?.locales.find(
+    (locale) => locale.code === project.localization.defaultLocale
+  );
+  const originalProject = fallback && primaryLocale ? getLocalizedProject2(project, primaryLocale.path) : project;
+  const contentSource = originalProject.sources.find(
+    (entry) => entry.id === source.id
+  );
+  const contentOptions = getSourceOptions4(originalProject, contentSource);
+  const contentCategories = fallback ? resolveDocsRoute2(originalProject, slug).categories : categories;
+  const contentLanguage = fallback ? primaryLocale.code : project.config.lang;
   const { content } = await compileDocumentation(
     document.content,
     getMdxComponents(project.config.lang),
     {
-      sourceRoot: getSourceOptions3(project, source).docsDir,
+      sourceRoot: contentOptions.docsDir,
       sourcePath: document.sourcePath,
       routePrefix: source.routePrefix,
-      documents: categories.flatMap((category2) => category2.pages)
+      basePath: contentSource.basePath,
+      virtualPaths: !!contentOptions.fallbackDocsDir,
+      documents: contentCategories.flatMap((category2) => category2.pages)
     }
   );
   const title = typeof document.frontmatter.title === "string" ? document.frontmatter.title : currentSlug;
   const description = typeof document.frontmatter.description === "string" ? document.frontmatter.description : null;
-  const hrefFor = (pageSlug) => ["/docs", source.routePrefix, pageSlug].filter(Boolean).join("/");
+  const hrefFor = (pageSlug) => getDocsHref3(project, source, pageSlug);
   const sidebarCategories = categories.map((category2) => ({
     title: category2.title,
     links: category2.pages.map((page) => ({
@@ -362,9 +474,58 @@ async function DocsPage({
                         "main",
                         {
                           id: "rdx-main",
+                          lang: contentLanguage,
                           tabIndex: -1,
                           className: "w-full flex flex-col gap-5 md:mx-auto md:max-w-[860px] pt-14 md:pt-0 flex-1 outline-none",
                           children: [
+                            fallback && /* @__PURE__ */ jsxs(
+                              Callout,
+                              {
+                                lang: project.config.lang,
+                                variant: "note",
+                                title: messages.translationUnavailable,
+                                "data-rdx-translation-fallback": true,
+                                children: [
+                                  /* @__PURE__ */ jsx("p", { children: formatMessage(messages.translationFallback, {
+                                    requested: project.locale.label,
+                                    original: primaryLocale.label
+                                  }) }),
+                                  /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-x-2", children: [
+                                    /* @__PURE__ */ jsx(
+                                      Button,
+                                      {
+                                        variant: "link",
+                                        href: getDocsHref3(
+                                          originalProject,
+                                          contentSource,
+                                          currentSlug
+                                        ),
+                                        children: messages.viewOriginal
+                                      }
+                                    ),
+                                    project.localization?.contributionUrl && /* @__PURE__ */ jsxs(
+                                      Button,
+                                      {
+                                        variant: "link",
+                                        href: project.localization.contributionUrl,
+                                        target: "_blank",
+                                        rel: "noopener noreferrer",
+                                        "data-rdx-translate-page": true,
+                                        children: [
+                                          messages.translateThisPage,
+                                          /* @__PURE__ */ jsxs("span", { className: "sr-only", children: [
+                                            " ",
+                                            "(",
+                                            messages.opensInNewTab,
+                                            ")"
+                                          ] })
+                                        ]
+                                      }
+                                    )
+                                  ] })
+                                ]
+                              }
+                            ),
                             /* @__PURE__ */ jsxs("header", { className: "mb-6", children: [
                               source.badge && /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground mb-4", children: source.badge === "Archived" ? messages.archivedVersion : source.badge }),
                               /* @__PURE__ */ jsx("span", { className: "text-xs text-zinc-600 font-semibold uppercase block -mb-0.5", children: category?.title }),
@@ -425,6 +586,7 @@ export {
   RdxLayout,
   createRdxProject,
   getDocumentMetadata,
+  getLocalizedProject3 as getLocalizedProject,
   getPageMetadata,
   getProjectDocsPaths,
   getRdxMetadata,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexibase/rdx-next",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "The Next.js runtime for RDX documentation projects.",
   "license": "MIT",
   "type": "module",
@@ -48,14 +48,15 @@
   "dependencies": {
     "cross-spawn": "^7.0.6",
     "jiti": "^2.6.1",
+    "prompts": "^2.4.2",
     "next-mdx-remote": "^6.0.0",
     "remark-gfm": "^4",
     "typescript": "6.0.3",
-    "@lexibase/rdx-types": "2.0.0",
-    "@lexibase/rdx-core": "2.0.0"
+    "@lexibase/rdx-core": "2.1.0",
+    "@lexibase/rdx-types": "2.1.0"
   },
   "peerDependencies": {
-    "@lexibase/rdx-ui": "^3.2.0",
+    "@lexibase/rdx-ui": "^3.3.0",
     "next": "^16.4.2",
     "react": "^19.3.1",
     "react-dom": "^19.3.1"
@@ -80,9 +81,9 @@
     "next": "^16.4.2",
     "react": "19.3.1",
     "react-dom": "19.3.1",
-    "@rdx/eslint-config": "1.0.0",
-    "@lexibase/rdx-ui": "3.2.1",
-    "@rdx/typescript-config": "1.0.0"
+    "@lexibase/rdx-ui": "3.3.0",
+    "@rdx/typescript-config": "1.0.0",
+    "@rdx/eslint-config": "1.0.0"
   },
   "scripts": {
     "dev": "tsup src/index.ts src/runtime/index.tsx --format esm --dts --watch --external @lexibase/rdx-core --external @lexibase/rdx-types --external @lexibase/rdx-ui --external next --external react --external react-dom --external next-mdx-remote",

package/templates/runtime/app/globals.css

@@ -4,3 +4,4 @@
 @source '../../home.{ts,tsx}';
 @source '../../components/**/*.{ts,tsx}';
 @source '../../docs/**/*.mdx';
+@source '../../locale/*/docs/**/*.mdx';