react-autolocale 0.1.0 → 0.2.0

package/dist/vite.js

@@ -1,456 +1,13 @@
-import { n as redirectScript } from "./redirect-CKNY4ru5.js";
+import { a as redirectScript, t as BANNER_EN } from "./suggestion-UZQ8ngd0.js";
+import { a as cacheDir, c as createLocalTranslator, d as toTranslator, f as unmask, i as readOverrides, l as mask, o as cacheFile, p as getLanguage, r as mergeOverrides, s as ensureTranslations, t as OVERRIDES_FILE, u as ollama } from "./overrides-ZQ6meLck.js";
 import fs from "node:fs";
 import path from "node:path";
-import { spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
-import os from "node:os";
-import { pathToFileURL } from "node:url";
 import { parse } from "@babel/parser";
 import _traverse from "@babel/traverse";
 import _generate from "@babel/generator";
 import * as t from "@babel/types";
 import { JSDOM, VirtualConsole } from "jsdom";
 import { createServer } from "vite";
-const byCode = new Map([
-	{
-		code: "en",
-		native: "English",
-		english: "English",
-		nllb: "eng_Latn"
-	},
-	{
-		code: "fr",
-		native: "Français",
-		english: "French",
-		nllb: "fra_Latn",
-		opus: "fr"
-	},
-	{
-		code: "es",
-		native: "Español",
-		english: "Spanish",
-		nllb: "spa_Latn",
-		opus: "es"
-	},
-	{
-		code: "de",
-		native: "Deutsch",
-		english: "German",
-		nllb: "deu_Latn",
-		opus: "de"
-	},
-	{
-		code: "it",
-		native: "Italiano",
-		english: "Italian",
-		nllb: "ita_Latn",
-		opus: "it"
-	},
-	{
-		code: "pt",
-		native: "Português",
-		english: "Portuguese",
-		nllb: "por_Latn"
-	},
-	{
-		code: "nl",
-		native: "Nederlands",
-		english: "Dutch",
-		nllb: "nld_Latn",
-		opus: "nl"
-	},
-	{
-		code: "ru",
-		native: "Русский",
-		english: "Russian",
-		nllb: "rus_Cyrl",
-		opus: "ru"
-	},
-	{
-		code: "zh",
-		native: "中文",
-		english: "Chinese (Simplified)",
-		nllb: "zho_Hans",
-		opus: "zh"
-	},
-	{
-		code: "ja",
-		native: "日本語",
-		english: "Japanese",
-		nllb: "jpn_Jpan"
-	},
-	{
-		code: "ko",
-		native: "한국어",
-		english: "Korean",
-		nllb: "kor_Hang"
-	},
-	{
-		code: "ar",
-		native: "العربية",
-		english: "Arabic",
-		nllb: "arb_Arab",
-		opus: "ar",
-		rtl: true
-	},
-	{
-		code: "hi",
-		native: "हिन्दी",
-		english: "Hindi",
-		nllb: "hin_Deva",
-		opus: "hi"
-	},
-	{
-		code: "tr",
-		native: "Türkçe",
-		english: "Turkish",
-		nllb: "tur_Latn"
-	},
-	{
-		code: "pl",
-		native: "Polski",
-		english: "Polish",
-		nllb: "pol_Latn"
-	},
-	{
-		code: "sv",
-		native: "Svenska",
-		english: "Swedish",
-		nllb: "swe_Latn",
-		opus: "sv"
-	},
-	{
-		code: "da",
-		native: "Dansk",
-		english: "Danish",
-		nllb: "dan_Latn",
-		opus: "da"
-	},
-	{
-		code: "no",
-		native: "Norsk",
-		english: "Norwegian",
-		nllb: "nob_Latn"
-	},
-	{
-		code: "fi",
-		native: "Suomi",
-		english: "Finnish",
-		nllb: "fin_Latn",
-		opus: "fi"
-	},
-	{
-		code: "cs",
-		native: "Čeština",
-		english: "Czech",
-		nllb: "ces_Latn",
-		opus: "cs"
-	},
-	{
-		code: "hu",
-		native: "Magyar",
-		english: "Hungarian",
-		nllb: "hun_Latn",
-		opus: "hu"
-	},
-	{
-		code: "ro",
-		native: "Română",
-		english: "Romanian",
-		nllb: "ron_Latn",
-		opus: "ro"
-	},
-	{
-		code: "uk",
-		native: "Українська",
-		english: "Ukrainian",
-		nllb: "ukr_Cyrl",
-		opus: "uk"
-	},
-	{
-		code: "el",
-		native: "Ελληνικά",
-		english: "Greek",
-		nllb: "ell_Grek"
-	},
-	{
-		code: "he",
-		native: "עברית",
-		english: "Hebrew",
-		nllb: "heb_Hebr",
-		rtl: true
-	},
-	{
-		code: "vi",
-		native: "Tiếng Việt",
-		english: "Vietnamese",
-		nllb: "vie_Latn",
-		opus: "vi"
-	},
-	{
-		code: "id",
-		native: "Bahasa Indonesia",
-		english: "Indonesian",
-		nllb: "ind_Latn",
-		opus: "id"
-	},
-	{
-		code: "th",
-		native: "ไทย",
-		english: "Thai",
-		nllb: "tha_Thai"
-	},
-	{
-		code: "bn",
-		native: "বাংলা",
-		english: "Bengali",
-		nllb: "ben_Beng"
-	},
-	{
-		code: "fa",
-		native: "فارسی",
-		english: "Persian",
-		nllb: "pes_Arab",
-		rtl: true
-	},
-	{
-		code: "ur",
-		native: "اردو",
-		english: "Urdu",
-		nllb: "urd_Arab",
-		rtl: true
-	},
-	{
-		code: "bg",
-		native: "Български",
-		english: "Bulgarian",
-		nllb: "bul_Cyrl"
-	},
-	{
-		code: "hr",
-		native: "Hrvatski",
-		english: "Croatian",
-		nllb: "hrv_Latn"
-	},
-	{
-		code: "sk",
-		native: "Slovenčina",
-		english: "Slovak",
-		nllb: "slk_Latn"
-	},
-	{
-		code: "ca",
-		native: "Català",
-		english: "Catalan",
-		nllb: "cat_Latn"
-	},
-	{
-		code: "ms",
-		native: "Bahasa Melayu",
-		english: "Malay",
-		nllb: "zsm_Latn"
-	},
-	{
-		code: "sw",
-		native: "Kiswahili",
-		english: "Swahili",
-		nllb: "swh_Latn"
-	},
-	{
-		code: "tl",
-		native: "Tagalog",
-		english: "Tagalog",
-		nllb: "tgl_Latn"
-	}
-].map((l) => [l.code, l]));
-function getLanguage(code) {
-	return byCode.get(code);
-}
-//#endregion
-//#region src/core/translate.ts
-const ENGINE_PACKAGE = "@huggingface/transformers@^4.3.1";
-const ENGINE_DIR = path.join(os.homedir(), ".cache", "react-autolocale", "engine");
-/**
-* Finds the translation engine. Uses the project's own copy if it has one; otherwise installs it once
-* into ~/.cache/react-autolocale/engine (shared by all projects, never touches the project's node_modules).
-*/
-async function loadEngine(log) {
-	try {
-		return await import("@huggingface/transformers");
-	} catch {}
-	const require = createRequire(path.join(ENGINE_DIR, "package.json"));
-	const find = () => require.resolve("@huggingface/transformers");
-	let entry;
-	try {
-		entry = find();
-	} catch {
-		log("[react-autolocale] Installing the translation engine (one time, about 440 MB)...");
-		fs.mkdirSync(ENGINE_DIR, { recursive: true });
-		const pkg = path.join(ENGINE_DIR, "package.json");
-		if (!fs.existsSync(pkg)) fs.writeFileSync(pkg, JSON.stringify({
-			name: "react-autolocale-engine",
-			private: true
-		}));
-		const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-		const res = spawnSync(npm, [
-			"install",
-			"--prefix",
-			ENGINE_DIR,
-			"--no-audit",
-			"--no-fund",
-			"--loglevel=error",
-			ENGINE_PACKAGE
-		], {
-			stdio: "inherit",
-			shell: process.platform === "win32"
-		});
-		try {
-			if (res.status !== 0) throw new Error("npm failed");
-			entry = find();
-		} catch {
-			throw new Error(`Could not install the translation engine automatically. Install it yourself: npm install -D @huggingface/transformers`);
-		}
-	}
-	const mod = await import(pathToFileURL(entry).href);
-	return mod.pipeline ? mod : mod.default;
-}
-const NLLB_MODEL = "Xenova/nllb-200-distilled-600M";
-const BATCH = 1;
-/**
-* Free, offline translation using Transformers.js (ONNX models run on the CPU).
-* Models are downloaded once from Hugging Face and cached in ~/.cache/react-autolocale.
-* English -> X uses small per-language OPUS-MT models where they exist; everything else uses NLLB-200.
-*/
-function createLocalTranslator(log = () => {}) {
-	const pipes = /* @__PURE__ */ new Map();
-	let hf = null;
-	const getPipe = (model) => {
-		let p = pipes.get(model);
-		if (!p) {
-			hf ??= loadEngine(log).then((m) => {
-				m.env.cacheDir = path.join(os.homedir(), ".cache", "react-autolocale", "models");
-				return m;
-			});
-			log(`Loading model ${model} (first run downloads it)...`);
-			let lastPct = -10;
-			p = hf.then((m) => m.pipeline("translation", model, {
-				dtype: "q8",
-				progress_callback: (e) => {
-					if (e.status === "progress" && e.progress - lastPct >= 10) {
-						lastPct = e.progress;
-						log(`  downloading ${e.file}: ${Math.round(e.progress)}%`);
-					}
-				}
-			}));
-			pipes.set(model, p);
-		}
-		return p;
-	};
-	const run = async (model, texts, options) => {
-		const pipe = await getPipe(model);
-		const out = [];
-		for (let i = 0; i < texts.length; i += BATCH) {
-			const res = await pipe(texts.slice(i, i + BATCH), {
-				max_new_tokens: 256,
-				...options
-			});
-			out.push(...res.map((r) => r.translation_text.trim()));
-		}
-		return out;
-	};
-	return { async translate(texts, from, to) {
-		const src = getLanguage(from);
-		const dst = getLanguage(to);
-		if (!src || !dst) throw new Error(`Unsupported language: ${!src ? from : to}`);
-		if (from === "en" && dst.opus) try {
-			return await run(`Xenova/opus-mt-en-${dst.opus}`, texts, {});
-		} catch (err) {
-			log(`  OPUS-MT model for "${to}" unavailable (${err.message}); falling back to NLLB.`);
-		}
-		return run(NLLB_MODEL, texts, {
-			src_lang: src.nllb,
-			tgt_lang: dst.nllb
-		});
-	} };
-}
-const token = (i) => `X${i}X`;
-/** Swaps excluded phrases for placeholders so the model leaves them alone. */
-function mask(text, exclude) {
-	const phrases = [];
-	let masked = text;
-	for (const phrase of [...exclude].sort((a, b) => b.length - a.length)) {
-		if (!phrase || !masked.includes(phrase)) continue;
-		masked = masked.split(phrase).join(token(phrases.length));
-		phrases.push(phrase);
-	}
-	return {
-		masked,
-		phrases
-	};
-}
-/** Puts excluded phrases back. Returns null if the model dropped or mangled a placeholder. */
-function unmask(translated, phrases) {
-	let out = translated;
-	for (let i = 0; i < phrases.length; i++) {
-		if (!out.includes(token(i))) return null;
-		out = out.split(token(i)).join(phrases[i]);
-	}
-	return /X\d+X/.test(out) ? null : out;
-}
-//#endregion
-//#region src/core/cache.ts
-/** Generated translations live here, outside the source tree. */
-function cacheDir(root) {
-	return path.join(root, "node_modules", ".cache", "react-autolocale");
-}
-function cacheFile(root, lang) {
-	return path.join(cacheDir(root), `${lang}.json`);
-}
-function readDict(file) {
-	try {
-		return JSON.parse(fs.readFileSync(file, "utf8"));
-	} catch {
-		return {};
-	}
-}
-/** Strings that are entirely an excluded phrase need no translation. */
-function needsTranslation(s, exclude) {
-	return !exclude.includes(s.trim());
-}
-/** Translates only strings missing from the cache, drops unused ones, and returns every language's dictionary. */
-async function ensureTranslations(opts) {
-	const { root, site, strings } = opts;
-	const log = opts.log ?? (() => {});
-	const wanted = strings.filter((s) => needsTranslation(s, site.exclude));
-	const result = {};
-	fs.mkdirSync(cacheDir(root), { recursive: true });
-	for (const lang of site.languages) {
-		const file = cacheFile(root, lang);
-		const existing = readDict(file);
-		const fixed = opts.overrides?.[lang] ?? {};
-		const missing = wanted.filter((s) => !existing[s] && !fixed[s]);
-		const next = {};
-		for (const s of wanted) if (existing[s]) next[s] = existing[s];
-		for (const s of wanted) if (fixed[s]) next[s] = fixed[s];
-		if (missing.length) {
-			log(`[react-autolocale] ${lang}: translating ${missing.length} new string${missing.length === 1 ? "" : "s"}...`);
-			const jobs = missing.map((s) => ({
-				source: s,
-				...mask(s, site.exclude)
-			}));
-			const out = await opts.getTranslator().translate(jobs.map((j) => j.masked), site.original, lang);
-			jobs.forEach((job, i) => {
-				const restored = unmask(out[i] ?? "", job.phrases);
-				if (restored) next[job.source] = restored;
-				else log(`[react-autolocale] ${lang}: kept "${job.source}" untranslated (could not preserve excluded text)`);
-			});
-		}
-		if (!(JSON.stringify(existing) === JSON.stringify(next))) fs.writeFileSync(file, JSON.stringify(next, null, 2) + "\n");
-		result[lang] = next;
-	}
-	return result;
-}
-//#endregion
 //#region src/core/transform.ts
 const traverse$2 = _traverse.default ?? _traverse;
 const generate = _generate.default ?? _generate;
@@ -474,6 +31,7 @@ const SKIP_ELEMENTS = /* @__PURE__ */ new Set([
 	"textarea"
 ]);
 const T_IMPORT = "__RLT";
+const TD_IMPORT = "__RLTD";
 const HOOK_IMPORT = "__rlUseT";
 const HOOK_VAR = "__rl";
 const RUNTIME = "react-autolocale";
@@ -503,13 +61,6 @@ function cleanJsxText(raw) {
 function isTranslatable(text) {
 	return /\p{L}/u.test(text);
 }
-/**
-* Text next to a `{expression}` is a sentence fragment ("Hello {name}"): translating the
-* pieces separately gives wrong results, so dynamic content is left for v2.
-*/
-function hasDynamicChild(node) {
-	return node.children.some((c) => t.isJSXExpressionContainer(c) && !t.isJSXEmptyExpression(c.expression) && !t.isStringLiteral(c.expression));
-}
 function isComponentName(name) {
 	return !!name && /^[A-Z]/.test(name);
 }
@@ -532,6 +83,58 @@ function enclosingComponent(path) {
 	}
 	return null;
 }
+/** `translate="no"` on an element (or any ancestor) keeps its text and attributes exactly as written. */
+function hasNoTranslate(opening) {
+	return opening.attributes.some((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name: "translate" }) && (t.isStringLiteral(a.value, { value: "no" }) || t.isJSXExpressionContainer(a.value) && t.isStringLiteral(a.value.expression, { value: "no" })));
+}
+function insideNoTranslate(path) {
+	for (let p = path; p; p = p.parentPath) if (p.isJSXElement() && hasNoTranslate(p.node.openingElement)) return true;
+	return false;
+}
+/** A value we can safely hand to the runtime: `name`, `user.name`, `this.props.count`, `items?.[0]`. */
+function simpleValueName(node) {
+	const root = (n) => t.isIdentifier(n) || t.isThisExpression(n) || (t.isMemberExpression(n) || t.isOptionalMemberExpression(n)) && root(n.object) && (n.computed ? t.isNumericLiteral(n.property) || t.isStringLiteral(n.property) : t.isIdentifier(n.property));
+	if (!root(node)) return null;
+	if (t.isIdentifier(node)) return node.name;
+	if ((t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) && !node.computed && t.isIdentifier(node.property)) return node.property.name;
+	return "value";
+}
+/**
+* "Hello {name}!" -> template "Hello {name}!" plus the values to fill in at runtime.
+* Only text mixed with plain variables qualifies: no nested elements, calls, conditions or JSX.
+*/
+function buildTemplate(node) {
+	let text = "";
+	const values = [];
+	const used = /* @__PURE__ */ new Set();
+	for (const child of node.children) if (t.isJSXText(child)) text += cleanJsxText(child.value);
+	else if (t.isJSXExpressionContainer(child)) {
+		const e = child.expression;
+		if (t.isJSXEmptyExpression(e)) continue;
+		if (t.isStringLiteral(e)) {
+			text += e.value;
+			continue;
+		}
+		const base = simpleValueName(e);
+		if (!base) return null;
+		let name = base;
+		for (let i = 2; used.has(name); i++) name = `${base}_${i}`;
+		used.add(name);
+		values.push({
+			name,
+			expr: e
+		});
+		text += `{${name}}`;
+	} else return null;
+	const letters = text.replace(/\{\w+\}/g, "");
+	if (!values.length || !isTranslatable(letters)) return null;
+	return {
+		text: text.trim(),
+		values,
+		lead: /^\s/.test(text),
+		trail: /\s$/.test(text)
+	};
+}
 /** Parses a file, extracts translatable strings, and rewrites JSX to render translations. */
 function transformJsx(code, file, opts = {}) {
 	const rewrite = opts.rewrite !== false;
@@ -547,14 +150,37 @@ function transformJsx(code, file, opts = {}) {
 		return null;
 	}
 	const strings = /* @__PURE__ */ new Set();
+	/** What kind of element each string sits in ("button", "h1", "placeholder", ...), for context-aware engines. */
+	const contexts = {};
+	const record = (text, context) => {
+		strings.add(text);
+		contexts[text] ??= context;
+	};
 	const hookTargets = /* @__PURE__ */ new Set();
 	let usedT = false;
+	let usedTD = false;
+	const space = () => t.jsxExpressionContainer(t.stringLiteral(" "));
 	traverse$2(ast, {
 		"JSXElement|JSXFragment"(path) {
 			const node = path.node;
 			const name = t.isJSXElement(node) && t.isJSXIdentifier(node.openingElement.name) ? node.openingElement.name.name : null;
 			if (name && SKIP_ELEMENTS.has(name)) return;
-			if (hasDynamicChild(node)) return;
+			if (insideNoTranslate(path)) return;
+			const context = name ?? "text";
+			if (node.children.some((c) => t.isJSXExpressionContainer(c) && !t.isJSXEmptyExpression(c.expression) && !t.isStringLiteral(c.expression))) {
+				const tpl = buildTemplate(node);
+				if (!tpl) return;
+				record(tpl.text, context);
+				if (!rewrite) return;
+				const valueObject = t.objectExpression(tpl.values.map((v) => t.objectProperty(t.identifier(v.name), t.cloneNode(v.expr))));
+				node.children = [
+					...tpl.lead ? [space()] : [],
+					t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TD_IMPORT), [t.jsxAttribute(t.jsxIdentifier("s"), t.stringLiteral(tpl.text)), t.jsxAttribute(t.jsxIdentifier("v"), t.jsxExpressionContainer(valueObject))], true), null, []),
+					...tpl.trail ? [space()] : []
+				];
+				usedTD = true;
+				return;
+			}
 			const children = [];
 			let changed = false;
 			for (const child of node.children) {
@@ -564,12 +190,11 @@ function transformJsx(code, file, opts = {}) {
 					children.push(child);
 					continue;
 				}
-				strings.add(text);
+				record(text, context);
 				if (!rewrite) {
 					children.push(child);
 					continue;
 				}
-				const space = () => t.jsxExpressionContainer(t.stringLiteral(" "));
 				if (/^\s/.test(cleaned)) children.push(space());
 				children.push(t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(T_IMPORT), [t.jsxAttribute(t.jsxIdentifier("s"), t.stringLiteral(text))], true), null, []));
 				if (/\s$/.test(cleaned)) children.push(space());
@@ -584,11 +209,12 @@ function transformJsx(code, file, opts = {}) {
 			if (!t.isStringLiteral(value)) return;
 			const opening = path.parent;
 			if (!t.isJSXIdentifier(opening.name) || !/^[a-z]/.test(opening.name.name)) return;
+			if (insideNoTranslate(path.parentPath.parentPath)) return;
 			const text = value.value.trim();
 			if (!text || !isTranslatable(text)) return;
 			const component = enclosingComponent(path);
 			if (!component) return;
-			strings.add(text);
+			record(text, name.name);
 			if (!rewrite) return;
 			path.node.value = t.jsxExpressionContainer(t.callExpression(t.identifier(HOOK_VAR), [t.stringLiteral(text)]));
 			hookTargets.add(component);
@@ -598,7 +224,8 @@ function transformJsx(code, file, opts = {}) {
 	if (!rewrite) return {
 		code,
 		map: null,
-		strings: [...strings]
+		strings: [...strings],
+		contexts
 	};
 	for (const fn of hookTargets) {
 		if (!t.isBlockStatement(fn.node.body)) fn.node.body = t.blockStatement([t.returnStatement(fn.node.body)]);
@@ -606,6 +233,7 @@ function transformJsx(code, file, opts = {}) {
 	}
 	const specifiers = [];
 	if (usedT) specifiers.push(t.importSpecifier(t.identifier(T_IMPORT), t.identifier("__T")));
+	if (usedTD) specifiers.push(t.importSpecifier(t.identifier(TD_IMPORT), t.identifier("__TD")));
 	if (hookTargets.size) specifiers.push(t.importSpecifier(t.identifier(HOOK_IMPORT), t.identifier("__useT")));
 	ast.program.body.unshift(t.importDeclaration(specifiers, t.stringLiteral(RUNTIME)));
 	const out = generate(ast, {
@@ -615,12 +243,17 @@ function transformJsx(code, file, opts = {}) {
 	return {
 		code: out.code,
 		map: out.map,
-		strings: [...strings]
+		strings: [...strings],
+		contexts
 	};
 }
-/** Strings only, without rewriting (used by `react-autolocale sync`). */
-function extractStrings(code, file) {
-	return transformJsx(code, file, { rewrite: false })?.strings ?? [];
+/** Strings (and where they appear), without rewriting. */
+function extractItems(code, file) {
+	const r = transformJsx(code, file, { rewrite: false });
+	return {
+		strings: r?.strings ?? [],
+		contexts: r?.contexts ?? {}
+	};
 }
 //#endregion
 //#region src/core/scan.ts
@@ -648,11 +281,21 @@ function* walk(dir) {
 		else if (isSourceFile(full)) yield full;
 	}
 }
-/** Every translatable string under the configured folders, in stable file order. */
-function scanProject(root, include) {
+/** Every translatable string under the configured folders, in stable file order, and where each appears. */
+function scanProjectDetailed(root, include) {
 	const found = /* @__PURE__ */ new Set();
-	for (const dir of include) for (const file of walk(path.resolve(root, dir))) for (const s of extractStrings(fs.readFileSync(file, "utf8"), file)) found.add(s);
-	return [...found];
+	const contexts = {};
+	for (const dir of include) for (const file of walk(path.resolve(root, dir))) {
+		const items = extractItems(fs.readFileSync(file, "utf8"), file);
+		for (const s of items.strings) {
+			found.add(s);
+			contexts[s] ??= items.contexts[s] ?? "";
+		}
+	}
+	return {
+		strings: [...found],
+		contexts
+	};
 }
 //#endregion
 //#region src/core/head.ts
@@ -685,6 +328,46 @@ function translateHead(doc, dict) {
 	}
 }
 //#endregion
+//#region src/core/banner.ts
+const FILE = (root) => path.join(cacheDir(root), "_banner.json");
+/** The banner's fixed phrases in every language, so a visitor sees them in their own language. */
+async function ensureBanner(opts) {
+	const source = JSON.stringify(BANNER_EN);
+	let cached = {};
+	try {
+		const file = JSON.parse(fs.readFileSync(FILE(opts.root), "utf8"));
+		if (file._source === source) cached = file;
+	} catch {}
+	const out = { en: BANNER_EN };
+	let changed = false;
+	const keys = Object.keys(BANNER_EN);
+	for (const lang of opts.langs) {
+		if (lang === "en") continue;
+		if (cached[lang]) {
+			out[lang] = cached[lang];
+			continue;
+		}
+		opts.log?.(`[react-autolocale] ${lang}: translating banner text...`);
+		const jobs = keys.map((k) => mask(BANNER_EN[k], ["{language}"]));
+		const translated = await opts.getTranslator().translate(jobs.map((j) => j.masked), "en", lang);
+		const text = { ...BANNER_EN };
+		keys.forEach((k, i) => {
+			text[k] = unmask(translated[i] ?? "", jobs[i].phrases) ?? BANNER_EN[k];
+		});
+		out[lang] = text;
+		cached[lang] = text;
+		changed = true;
+	}
+	if (changed) {
+		fs.mkdirSync(cacheDir(opts.root), { recursive: true });
+		fs.writeFileSync(FILE(opts.root), JSON.stringify({
+			_source: source,
+			...cached
+		}, null, 2) + "\n");
+	}
+	return out;
+}
+//#endregion
 //#region src/core/routes.ts
 const traverse$1 = _traverse.default ?? _traverse;
 function str(node) {
@@ -1120,27 +803,36 @@ function reactAutolocale(options = {}) {
 	let includeDirs = [];
 	let site;
 	let dicts = {};
+	let banner = {};
 	let translator;
 	let server;
 	let rendered = false;
 	const log = (msg) => console.log(msg);
-	const getTranslator = () => translator ??= createLocalTranslator(log);
+	const getTranslator = () => translator ??= options.engine ? toTranslator(options.engine) : createLocalTranslator(log);
 	async function refresh() {
 		include = options.include ?? defaultInclude(root);
 		includeDirs = include.map((d) => path.resolve(root, d) + path.sep);
 		site = findSite(root, include);
-		const strings = scanProject(root, include);
+		const { strings, contexts } = scanProjectDetailed(root, include);
 		if (site.seo) {
 			const html = path.join(root, "index.html");
 			if (fs.existsSync(html)) strings.push(...headStrings(fs.readFileSync(html, "utf8")));
 		}
+		banner = await ensureBanner({
+			root,
+			langs: [site.original, ...site.languages],
+			getTranslator,
+			log
+		});
 		dicts = await ensureTranslations({
 			root,
 			site,
 			strings,
 			getTranslator,
 			log,
-			overrides: options.overrides
+			contexts,
+			glossary: options.glossary,
+			overrides: mergeOverrides(readOverrides(root), options.overrides)
 		});
 	}
 	function virtualModule() {
@@ -1154,6 +846,7 @@ function reactAutolocale(options = {}) {
 			`export const original = ${JSON.stringify(site.original)};`,
 			`export const originalNative = ${JSON.stringify(getLanguage(site.original)?.native ?? site.original)};`,
 			`export const seo = ${JSON.stringify(site.seo)};`,
+			`export const banner = ${JSON.stringify(banner)};`,
 			`export const languages = ${JSON.stringify(meta)};`,
 			`export const loaders = { ${loaders.join(", ")} };`
 		].join("\n");
@@ -1193,6 +886,9 @@ function reactAutolocale(options = {}) {
 		},
 		configureServer(s) {
 			server = s;
+			const file = path.resolve(root, OVERRIDES_FILE);
+			s.watcher.add(file);
+			s.watcher.on("change", (changed) => changed === file && scheduleRefresh());
 		},
 		async buildStart() {
 			if (config.build.ssr) return;
@@ -1239,4 +935,4 @@ function reactAutolocale(options = {}) {
 	};
 }
 //#endregion
-export { reactAutolocale as default, reactAutolocale };
+export { reactAutolocale as default, reactAutolocale, ollama };