@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/test.js

@@ -0,0 +1,319 @@
+import { c as page, n as S, p as subs, r as changed, t as textDirection } from "./dir-zw6bGMKQ.js";
+import { c as parseICU, i as normalizeSource, n as canonicalize, t as compileMessage } from "./compile-Cc97JaW2.js";
+import { t as createScopedApi } from "./scoped-BMYpSthj.js";
+import { t as pseudoLocalize } from "./pseudo-DRv30iN5.js";
+//#region src/test/catalog.ts
+/**
+* `loadCatalog` (INTERNALS §3.8, §6 D194): one locale's translations read
+* from the project's catalog files, as the build compiles them, for
+* `createTestI18n({ catalog })`. The Node side loads on first use, so the
+* `/test` entry itself stays loadable in browser test runners.
+*/
+const loads = /* @__PURE__ */ new Map();
+/**
+* The locale's translations, fallbacks applied; untranslated and unusable
+* entries are left out, so those messages render their source text, as in
+* `vite dev`. Memoised per project and locale for the test file.
+*/
+function loadCatalog(locale, options = {}) {
+	const project = S.registration?.project;
+	const root = options.root ?? project?.root ?? globalThis.process?.cwd() ?? ".";
+	const configFile = options.configFile ?? (options.root === void 0 ? project?.configFile : void 0) ?? null;
+	const key = JSON.stringify([
+		root,
+		configFile,
+		locale
+	]);
+	let load = loads.get(key);
+	if (load === void 0) {
+		load = import("./load-CQRz4PpM.js").then((m) => m.compileCatalog(locale, root, configFile));
+		loads.set(key, load);
+		load.catch(() => loads.delete(key));
+	}
+	return load;
+}
+//#endregion
+//#region src/test/i18n.ts
+/**
+* `createTestI18n` (PLAN §5.22, INTERNALS §3.8): unit and component tests
+* render in a locale, with real or hand-written translations, with message
+* ids or pseudo text, and with a fixed time zone and `now`.
+*
+* It configures the page scope, the scope `t()` resolves in a test (under
+* the plugin's test registration and without the plugin), rather than a
+* scope of its own: components import the global `t`, and mounted ones
+* re-render through their glue's trackers (§6 D190). The scope's `test` hook
+* picks every message, because only it sees the descriptor (§6 D189).
+*/
+const DEFAULT_NOW = Date.UTC(2026, 0, 1);
+const PSEUDO = /* @__PURE__ */ new Set(["en-XA", "ar-XB"]);
+/** What the page held before the first `createTestI18n`; null while nothing is applied. */
+let saved = null;
+const html = () => typeof document === "object" && document?.documentElement ? document.documentElement : null;
+function notify() {
+	changed(true);
+	for (const fn of subs) fn(page.locale);
+}
+/** Puts the page back as the first `createTestI18n` found it. */
+function resetTestI18n() {
+	const s = saved;
+	if (s === null) return;
+	saved = null;
+	page.locale = s.locale;
+	page.messages = s.messages;
+	page.timeZone = s.timeZone;
+	page.now = s.now;
+	page.labels = s.labels;
+	delete page.test;
+	S.registration = s.registration;
+	S.locales.splice(0, S.locales.length, ...s.locales);
+	const h = html();
+	if (h && s.html) Object.assign(h, s.html);
+	notify();
+}
+/** A registration for suites the plugin does not run in, so `t()` and `/server` treat them as tests. */
+function testRegistration(locale) {
+	const locales = [.../* @__PURE__ */ new Set(["en", locale])];
+	return {
+		mode: "dev",
+		consumer: "client",
+		config: {
+			sourceLocale: "en",
+			locales,
+			pseudoLocales: locales.filter((l) => PSEUDO.has(l)),
+			fallbacks: {},
+			routing: {
+				strategy: ["default"],
+				routeStrategies: {},
+				url: "no_prefix",
+				redirectRoot: false,
+				propagate: false,
+				switch: "in-place",
+				cookie: {
+					name: "vi18n_locale",
+					maxAge: 31536e3
+				},
+				base: "/"
+			},
+			ssr: {
+				timeZone: "UTC",
+				timeZoneFrom: {},
+				normalizeSpaces: true
+			}
+		},
+		test: true
+	};
+}
+function memo(cache, key, make) {
+	let value = cache.get(key);
+	if (value === void 0) {
+		if (cache.size > 9999) cache.clear();
+		cache.set(key, value = make());
+	}
+	return value;
+}
+const parsed = /* @__PURE__ */ new Map();
+const sourceIr = /* @__PURE__ */ new Map();
+const pseudoIr = /* @__PURE__ */ new Map();
+const canonical = /* @__PURE__ */ new Map();
+function parse(source) {
+	return memo(parsed, source, () => {
+		try {
+			return parseICU(normalizeSource(source));
+		} catch (error) {
+			throw new Error(`vi18n: ${JSON.stringify(source)} is not a valid message: ${error.message}`, { cause: error });
+		}
+	});
+}
+const compiled = (source) => memo(sourceIr, source, () => compileMessage(parse(source)));
+/** The text as a build's pseudo-locale renders it (`compileLocales` does the same). */
+const pseudo = (source, locale) => memo(pseudoIr, locale + "\0" + source, () => compileMessage(pseudoLocalize(parse(source), locale)));
+/** The canonical form, or the text itself when it does not parse (it then matches nothing). */
+const canonicalOf = (source) => memo(canonical, source, () => {
+	try {
+		return canonicalize(source);
+	} catch {
+		return source;
+	}
+});
+/**
+* A generated id (INTERNALS §2.2.1): sha256 of the canonical text plus
+* U+001F, base64url. Read through `getBuiltinModule` so the entry loads in
+* browser test runners too; only this mode needs Node there.
+*/
+function generatedId(canonicalText, length) {
+	const crypto = globalThis.process?.getBuiltinModule?.("node:crypto");
+	if (crypto === void 0) throw new Error("vi18n: ids mode needs node:crypto for calls the plugin did not rewrite; run the test under the plugin or in Node");
+	return crypto.hash("sha256", canonicalText + "", "base64url").slice(0, length);
+}
+function check(condition, message) {
+	if (!condition) throw new RangeError("vi18n: " + message);
+}
+/**
+* Renders every `t()` of the test in `options.locale` and `options.mode`
+* until `reset()` (or the next `createTestI18n`, which replaces it). Without
+* a call, tests under the plugin render the source locale as before.
+*/
+function createTestI18n(options = {}) {
+	const mode = options.mode ?? "source";
+	check([
+		"source",
+		"ids",
+		"pseudo"
+	].includes(mode), `unknown test mode ${JSON.stringify(mode)}`);
+	const timeZone = options.timeZone ?? "UTC";
+	new Intl.DateTimeFormat("en", { timeZone });
+	const now = options.now instanceof Date ? options.now.getTime() : options.now ?? DEFAULT_NOW;
+	check(Number.isFinite(now), "now must be a finite time");
+	const idLength = options.idLength ?? 12;
+	check(Number.isInteger(idLength) && idLength >= 8 && idLength <= 16, "idLength must be an integer from 8 to 16");
+	const catalog = options.catalog;
+	const requested = options.locale ?? catalog?.locale;
+	if (catalog && requested !== catalog.locale) throw new RangeError(`vi18n: the catalog is for ${catalog.locale}, not ${requested}`);
+	const own = /* @__PURE__ */ new Map();
+	for (const [key, text] of Object.entries(options.messages ?? {})) own.set(canonicalOf(key), compiled(text));
+	const base = saved ? saved.registration : S.registration;
+	const locale = requested ?? (mode === "pseudo" ? "en-XA" : base?.config.sourceLocale ?? "en");
+	Intl.getCanonicalLocales(locale);
+	check(base === null || base.config.locales.includes(locale) || PSEUDO.has(locale), `unknown locale ${locale} (${base?.config.locales.join(", ")})`);
+	const h = html();
+	saved ??= {
+		locale: page.locale,
+		messages: page.messages,
+		timeZone: page.timeZone,
+		now: page.now,
+		labels: page.labels,
+		registration: S.registration,
+		locales: [...S.locales],
+		html: h && {
+			lang: h.lang,
+			dir: h.dir
+		}
+	};
+	if (base === null) S.register(testRegistration(locale));
+	const style = locale === "ar-XB" ? "ar-XB" : "en-XA";
+	page.locale = locale;
+	page.messages = catalog?.messages ?? saved.messages;
+	page.timeZone = timeZone;
+	page.now = now;
+	page.test = (id, d, text) => {
+		const source = d?.message ?? text;
+		if (mode === "ids") return d?.id ?? (page.messages.has(id) ? id : generatedId(canonicalOf(source), idLength));
+		if (mode === "pseudo") return pseudo(source, style);
+		if (page.locale === locale && own.size > 0) {
+			const m = own.get(id) ?? own.get(canonicalOf(source));
+			if (m !== void 0) return m;
+		}
+		return page.messages.get(id) ?? d?.ir ?? compiled(source);
+	};
+	if (h) Object.assign(h, {
+		lang: locale,
+		dir: textDirection(locale)
+	});
+	notify();
+	return {
+		...createScopedApi(page),
+		mode,
+		reset: resetTestI18n
+	};
+}
+//#endregion
+//#region src/test/pseudo.ts
+const LETTER = /\p{L}/u;
+const BIDI_CONTROL = /[\u202A-\u202E\u2066-\u2069\u200E\u200F]/g;
+/**
+* Runs of letters at bracket depth 0 in `text`. The depth is per line: page
+* text joins blocks with newlines, and a stray `]` in one block must not hide
+* a leak in the next.
+*/
+function findPseudoLeaks(text, options = {}) {
+	const allow = (options.allow ?? []).map((a) => typeof a === "string" ? (run) => run.split(a).join(" ") : (run) => run.replace(new RegExp(a.source, a.flags.includes("g") ? a.flags : a.flags + "g"), " "));
+	const isAllowed = (run) => !LETTER.test(allow.reduce((rest, cut) => cut(rest), run));
+	const leaks = [];
+	for (const line of text.replace(BIDI_CONTROL, "").split("\n")) {
+		let depth = 0;
+		let run = "";
+		let runStart = 0;
+		const flush = (end) => {
+			const trimmed = run.trim();
+			if (trimmed && LETTER.test(trimmed) && !isAllowed(trimmed)) leaks.push({
+				text: trimmed,
+				context: line.slice(Math.max(0, runStart - 10), Math.min(line.length, end + 10))
+			});
+			run = "";
+		};
+		for (let i = 0; i < line.length; i++) {
+			const ch = line[i];
+			if (ch === "[") {
+				if (depth === 0) flush(i);
+				depth++;
+			} else if (ch === "]") {
+				depth = Math.max(0, depth - 1);
+				if (depth === 0) runStart = i + 1;
+			} else if (depth === 0) {
+				if (!run) runStart = i;
+				run += ch;
+			}
+		}
+		flush(line.length);
+	}
+	return leaks;
+}
+/**
+* The visible text of the page's document, one line per block. Runs in the
+* page, so it is self-contained. Inline siblings stay on one line, so a
+* message split by markup (`[Ŕéáď ţĥé <a>ďóçš</a>]`) is joined back.
+*/
+function pageText(arg) {
+	const skip = [
+		"script",
+		"style",
+		"noscript",
+		"template",
+		"[data-pseudo-ignore]"
+	].concat(arg).join(",");
+	const out = [document.title, "\n"];
+	const visit = (node) => {
+		if (node.nodeType === Node.TEXT_NODE) {
+			const parent = node.parentElement;
+			if (parent && !parent.closest(skip)) out.push(node.nodeValue ?? "");
+			return;
+		}
+		if (!(node instanceof Element)) return;
+		if (node.matches(skip)) return;
+		if (typeof node.checkVisibility === "function" && !node.checkVisibility()) return;
+		const display = getComputedStyle(node).display;
+		const block = display !== "inline" && display !== "contents" && !display.startsWith("inline-");
+		if (block) out.push("\n");
+		for (const child of node.childNodes) visit(child);
+		if (block) out.push("\n");
+	};
+	visit(document.body);
+	return out.join("");
+}
+/** Text outside pseudo brackets on the page as it is now; empty means clean. */
+async function scanPseudo(page, options = {}) {
+	return findPseudoLeaks(await page.evaluate(pageText, [...options.ignore ?? []]), options);
+}
+/**
+* Switches the page to a pseudo-locale through its own vi18n runtime
+* (`setLocale`, in place or by navigation, as the app's routing does it) and
+* waits until `<html lang>` names it and its strings are loaded. Pseudo-locales
+* exist in `vite dev` and non-production builds that list them in
+* `pseudoLocales`.
+*/
+async function setPseudoLocale(page, locale = "en-XA", options = {}) {
+	const problem = await page.evaluate(async (arg) => {
+		const l = arg;
+		const state = globalThis[Symbol.for("menapo.vi18n")];
+		if (!state?.locales) return "vi18n is not loaded on this page";
+		if (!state.locales.includes(l)) return `${l} is not an active locale here (${state.locales.join(", ")})`;
+		await state.setLocale(l);
+		return null;
+	}, locale).catch(() => null);
+	if (typeof problem === "string") throw new Error(`vi18n: ${problem}; pseudo-locales exist in vite dev and in builds of another mode than production (vite build --mode staging) that list them in pseudoLocales`);
+	await page.waitForFunction((arg) => document.documentElement.lang === arg, locale, options.timeout === void 0 ? {} : { timeout: options.timeout });
+	await page.evaluate(() => globalThis[Symbol.for("menapo.vi18n")]?.ready());
+}
+//#endregion
+export { createTestI18n, findPseudoLeaks, loadCatalog, resetTestI18n, scanPseudo, setPseudoLocale };

package/dist/translate-CQnJfLjO.js

@@ -0,0 +1,299 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { a as ownedMessages, n as libraryCoverage, o as catalogLayout } from "./library-D5CWvTQs.js";
+import { a as table, r as plural } from "./output-DWE3SIUA.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { a as loadCatalogs, f as scan, i as hasErrors, o as loadProject, p as targetLocales, t as CliExit, u as readErrors } from "./project-C4GpaN-n.js";
+import { t as adaptiveConcurrency } from "./concurrency-C9UUWuDC.js";
+import { a as firstRequests, c as runTranslations, i as estimateUsage, n as catalogPersister, o as planTranslations, r as createProvider, s as replayProvider } from "./pipeline-C9Dbotkh.js";
+//#region src/cli/commands/translate.ts
+/**
+* `vi18n translate [--locale l]… [--provider name] [--model id] [--tier t]
+* [--retranslate ai|all] [--dry-run] [--max-cost usd]` (INTERNALS §2.15,
+* PLAN §5.20): plan every locale against the catalogs on disk, estimate,
+* then translate one locale after another, writing each finished batch
+* before the next is paid for. Exit 1 when any item still failed after its
+* retries.
+*
+* `--tier batch` first submits every locale's first requests as Gemini
+* batch jobs and waits for them; their answers then replay into the same
+* per-locale runs, whose retries go out synchronously.
+*/
+async function translate(ctx, flags) {
+	const project = await loadProject(ctx);
+	const { config, codec } = project;
+	const locales = targetLocales(config, flags.locales);
+	const scanned = await scan(project);
+	ctx.out.report(scanned.diagnostics.filter((d) => d.severity === "error"));
+	const loaded = await loadCatalogs(project);
+	const unreadable = readErrors(loaded.diagnostics);
+	let provider;
+	try {
+		provider = createProvider(config, {
+			...flags.model === null ? {} : { model: flags.model },
+			...flags.provider === null ? {} : { provider: flags.provider },
+			tier: flags.tier,
+			...ctx.io.fetch === void 0 ? {} : { fetch: ctx.io.fetch },
+			env: ctx.io.env
+		});
+	} catch (error) {
+		if (isDiagnosticError(error)) throw new CliExit(EXIT.usage, [error.diagnostic]);
+		throw error;
+	}
+	if (typeof provider.apiKeyEnv === "string") ctx.out.addSecret(ctx.io.env[provider.apiKeyEnv]);
+	const configured = config.ai.provider;
+	if (flags.model !== null && flags.provider === null && configured !== "gemini" && configured.withModel === void 0) ctx.out.note(`vi18n: --model is ignored: ai.provider is a custom provider (${provider.name}, ${provider.model})`);
+	const data = {
+		dryRun: flags.dryRun,
+		provider: provider.name,
+		model: provider.model,
+		tier: flags.tier,
+		locales: [],
+		estimate: {
+			requests: 0,
+			inputTokens: 0,
+			outputTokens: 0,
+			cost: 0
+		}
+	};
+	if (unreadable.length > 0) {
+		ctx.out.report(unreadable);
+		return {
+			exitCode: EXIT.failure,
+			data
+		};
+	}
+	const plans = /* @__PURE__ */ new Map();
+	const coverage = libraryCoverage(loaded.set, scanned.messages, config, codec);
+	for (const locale of locales) {
+		const plan = planTranslations({
+			config,
+			codec,
+			messages: ownedMessages(scanned.messages, locale, loaded.set.get(locale)?.catalog ?? null, coverage, {
+				sourceLocale: config.sourceLocale,
+				layout: catalogLayout(config),
+				codec
+			}),
+			catalogs: loaded.set,
+			locale,
+			retranslate: flags.retranslate
+		});
+		plans.set(locale, plan);
+		const usage = estimateUsage({
+			config,
+			locale,
+			plan
+		});
+		const estimate = {
+			...usage,
+			cost: costOf(provider, usage)
+		};
+		data.locales.push({
+			...emptySummary(locale),
+			estimate
+		});
+		addEstimate(data.estimate, estimate);
+	}
+	if (flags.maxCost !== null && data.estimate.requests > 0) {
+		const cost = data.estimate.cost;
+		if (cost === null || cost > flags.maxCost) {
+			ctx.out.report([{
+				code: "ai-cost-limit",
+				severity: "error",
+				message: cost === null ? `no price for ${provider.model}, so the cost of ${plural(data.estimate.requests, "request")} cannot be checked against --max-cost ${flags.maxCost}; nothing was sent` : `the estimated cost ${usd(cost)} of ${plural(data.estimate.requests, "request")} is over --max-cost ${usd(flags.maxCost)}; nothing was sent${flags.dryRun ? "" : " (see vi18n translate --dry-run)"}`
+			}]);
+			if (flags.dryRun) printEstimate(ctx, data);
+			return {
+				exitCode: EXIT.failure,
+				data
+			};
+		}
+	}
+	if (flags.dryRun) {
+		printEstimate(ctx, data);
+		return {
+			exitCode: hasErrors(ctx.out.diagnostics) ? EXIT.failure : EXIT.ok,
+			data
+		};
+	}
+	if (data.estimate.requests > 0) {
+		const missing = provider.missingKey?.() ?? null;
+		if (missing !== null) {
+			ctx.out.report([missing]);
+			return {
+				exitCode: EXIT.failure,
+				data
+			};
+		}
+	}
+	let failed = false;
+	let finished = 0;
+	const aborted = () => ctx.io.signal?.aborted === true;
+	const interrupted = () => {
+		data.interrupted = true;
+		data.locales = data.locales.filter((_, index) => index < finished);
+		ctx.out.note("vi18n translate: interrupted; finished batches are saved, rerun to translate the rest");
+		return {
+			exitCode: EXIT.failure,
+			data
+		};
+	};
+	let runner = provider;
+	if (flags.tier === "batch" && data.estimate.requests > 0) {
+		const requests = [];
+		for (const locale of locales) requests.push(...firstRequests({
+			config,
+			locale,
+			plan: plans.get(locale) ?? []
+		}));
+		if (provider.translateBatch === void 0) throw new CliExit(EXIT.usage, [{
+			code: "config-invalid",
+			severity: "error",
+			message: `--tier batch needs a provider with a batch API, not ${provider.name}`
+		}]);
+		ctx.out.note(`vi18n translate: sending ${plural(requests.length, "request")} as batch jobs; results can take minutes to hours (Ctrl-C cancels)`);
+		const states = /* @__PURE__ */ new Map();
+		try {
+			const answers = await provider.translateBatch(requests, {
+				...ctx.io.signal === void 0 ? {} : { signal: ctx.io.signal },
+				onProgress: ({ job, state }) => {
+					if (states.get(job) === state) return;
+					states.set(job, state);
+					ctx.out.note(`vi18n translate: ${job}: ${state}`);
+				}
+			});
+			runner = replayProvider(provider, requests, answers);
+		} catch (error) {
+			if (aborted()) return interrupted();
+			if (!isDiagnosticError(error)) throw error;
+			ctx.out.report([error.diagnostic]);
+			return {
+				exitCode: EXIT.failure,
+				data
+			};
+		}
+	}
+	const concurrency = adaptiveConcurrency(config.ai.concurrency);
+	for (let i = 0; i < locales.length; i++) {
+		if (aborted()) return interrupted();
+		const locale = locales[i];
+		const plan = plans.get(locale);
+		const persist = catalogPersister({
+			config,
+			codec,
+			locale,
+			messages: scanned.messages,
+			catalog: loaded.set.get(locale),
+			sourceCatalog: loaded.set.get(config.sourceLocale),
+			model: provider.model
+		});
+		let summary;
+		try {
+			summary = await runTranslations({
+				provider: runner,
+				config,
+				locale,
+				plan,
+				persist,
+				concurrency,
+				...ctx.io.signal === void 0 ? {} : { signal: ctx.io.signal }
+			});
+		} catch (error) {
+			if (aborted()) return interrupted();
+			if (!isDiagnosticError(error)) throw error;
+			ctx.out.report([{
+				...error.diagnostic,
+				locale: error.diagnostic.locale ?? locale
+			}]);
+			return {
+				exitCode: EXIT.failure,
+				data
+			};
+		}
+		const entry = data.locales[i];
+		Object.assign(entry, summary, { estimate: entry.estimate });
+		ctx.out.report(summaryDiagnostics(summary));
+		if (summary.failed.length > 0) failed = true;
+		if (summary.rateLimited !== void 0) ctx.out.note(`vi18n translate: ${locale} was rate-limited ${plural(summary.rateLimited.count, "time")}; requests in flight now ${summary.rateLimited.concurrency} of ${concurrency.max}`);
+		finished = i + 1;
+		ctx.out.result(`${locale}: ${summary.translated} translated, ${summary.reused} reused, ${summary.failed.length} failed of ${summary.requested} requested (${summary.usage.inputTokens} input / ${summary.usage.outputTokens} output tokens)`);
+	}
+	return {
+		exitCode: failed || hasErrors(ctx.out.diagnostics) ? EXIT.failure : EXIT.ok,
+		data
+	};
+}
+function emptySummary(locale) {
+	return {
+		locale,
+		requested: 0,
+		translated: 0,
+		reused: 0,
+		identical: [],
+		failed: [],
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0
+		}
+	};
+}
+/** USD from the provider's pinned price table; null when it has none for the model. */
+function costOf(provider, usage) {
+	if (usage.inputTokens === 0 && usage.outputTokens === 0) return 0;
+	const cost = provider.estimateCost?.(usage) ?? NaN;
+	return Number.isFinite(cost) ? cost : null;
+}
+function addEstimate(total, part) {
+	total.requests += part.requests;
+	total.inputTokens += part.inputTokens;
+	total.outputTokens += part.outputTokens;
+	total.cost = total.cost === null || part.cost === null ? null : total.cost + part.cost;
+}
+function usd(value) {
+	return `$${value < .01 && value > 0 ? value.toFixed(4) : value.toFixed(2)}`;
+}
+function printEstimate(ctx, data) {
+	const rows = data.locales.map((l) => [
+		l.locale,
+		l.estimate.requests,
+		l.estimate.inputTokens,
+		l.estimate.outputTokens,
+		l.estimate.cost === null ? "no price" : usd(l.estimate.cost)
+	]);
+	const t = data.estimate;
+	rows.push([
+		"total",
+		t.requests,
+		t.inputTokens,
+		t.outputTokens,
+		t.cost === null ? "no price" : usd(t.cost)
+	]);
+	ctx.out.result(table([
+		"locale",
+		"requests",
+		"input tokens",
+		"output tokens",
+		"cost"
+	], rows));
+	const tier = data.tier === "standard" ? "" : `, ${data.tier} tier`;
+	ctx.out.result(`dry run with ${data.model}${tier}: nothing was sent (tokens estimated at 4 characters each)`);
+}
+function summaryDiagnostics(summary) {
+	const out = [];
+	for (const id of summary.identical) out.push({
+		code: "ai-identical-output",
+		severity: "info",
+		message: `the ${summary.locale} translation of ${id} is identical to the source (often right for names and words like "OK"); review it if unexpected`,
+		locale: summary.locale,
+		id
+	});
+	for (const failure of summary.failed) out.push({
+		code: "ai-validation-failed",
+		severity: "error",
+		message: `${failure.id} was left untranslated after its retries: ${failure.checks.join("; ")}`,
+		locale: summary.locale,
+		id: failure.id
+	});
+	return out;
+}
+//#endregion
+export { translate };