@babelize/engine 0.1.0 → 0.1.3

package/dist/modules/workspace/validate.js

@@ -43,27 +43,46 @@ const fast_glob_1 = __importDefault(require("fast-glob"));
 const types_1 = require("@babelize/types");
 const logger_1 = require("../../utils/logger");
 const file_utils_1 = require("../../utils/file-utils");
-// Python/Django detection — runs BEFORE the static fallback
-async function detectPythonFramework(workspacePath) {
-    // Check for manage.py (Django)
-    if (await (0, file_utils_1.pathExists)(path.join(workspacePath, 'manage.py'))) {
-        return 'django';
+const stack_1 = require("../../detection/stack");
+const django_finalize_1 = require("../finalization/django-finalize");
+const locale_names_1 = require("../../django/locale-names");
+const PY_IGNORE = ['**/node_modules/**', '**/.venv/**', '**/venv/**', '**/site-packages/**', '**/.git/**'];
+/**
+ * The Django project root (directory of the shallowest manage.py), relative
+ * to the workspace, or null when this isn't a Django project. A root-level
+ * package.json with a supported JS framework wins over a nested manage.py.
+ */
+async function detectDjangoRoot(workspacePath, rootJsFramework) {
+    if (await (0, file_utils_1.pathExists)(path.join(workspacePath, 'manage.py')))
+        return '.';
+    if (rootJsFramework !== 'unknown')
+        return null;
+    const manage = await (0, fast_glob_1.default)('**/manage.py', { cwd: workspacePath, onlyFiles: true, deep: 4, ignore: PY_IGNORE });
+    if (manage.length > 0) {
+        const shallowest = manage.sort((a, b) => a.split('/').length - b.split('/').length || a.localeCompare(b))[0];
+        return path.posix.dirname(shallowest) || '.';
     }
-    // Check for Django in requirements/pyproject
-    const configFiles = ['pyproject.toml', 'requirements.txt', 'Pipfile'];
-    for (const file of configFiles) {
+    const depFiles = ['pyproject.toml', 'requirements.txt', 'Pipfile', 'setup.py', 'setup.cfg'];
+    for (const file of depFiles) {
         const content = await (0, file_utils_1.readFile)(path.join(workspacePath, file)).catch(() => '');
-        if (content && /django/i.test(content)) {
-            return 'django';
-        }
-    }
-    // Check for settings.py
-    const settingsFiles = await (0, fast_glob_1.default)('**/settings.py', { cwd: workspacePath, onlyFiles: true, deep: 4 });
-    if (settingsFiles.length > 0) {
-        return 'django';
+        if (content && (0, stack_1.mentionsPythonPackage)(content, 'django'))
+            return '.';
     }
     return null;
 }
+const SUPPORTED_LIST = 'React, Next.js, Vue, Django and plain HTML/CSS/JS';
+/** The clearest "not supported" message for a workspace we couldn't classify. */
+async function unsupportedMessage(workspacePath, fallback) {
+    try {
+        const stack = await (0, stack_1.detectStack)(await (0, stack_1.localRepoFiles)(workspacePath));
+        if (stack.unsupported)
+            return stack.message;
+    }
+    catch {
+        // fall through
+    }
+    return fallback;
+}
 async function validateWorkspace(config) {
     const { workspacePath } = config;
     if (!(await (0, file_utils_1.pathExists)(workspacePath))) {
@@ -80,14 +99,18 @@ async function validateWorkspace(config) {
         framework = config.framework;
         logger_1.engineLogger.info('Using explicit framework override', { framework });
     }
-    if (!framework || framework === 'unknown') {
-        const pythonFramework = await detectPythonFramework(workspacePath);
-        if (pythonFramework) {
-            framework = pythonFramework;
-            logger_1.engineLogger.info('Detected Python framework', { framework });
+    let djangoRoot = null;
+    if (!framework || framework === 'unknown' || framework === 'django') {
+        djangoRoot = await detectDjangoRoot(workspacePath, packageJson ? detectFramework(packageJson) : 'unknown');
+        if (djangoRoot !== null) {
+            framework = 'django';
+            logger_1.engineLogger.info('Detected Django project', { djangoRoot });
+        }
+        else if (framework === 'django') {
+            throw new Error('This project was set up as Django, but no manage.py or Django dependency was found.');
         }
     }
-    if (!packageJson) {
+    if (!packageJson && framework !== 'django') {
         const htmlFiles = await (0, fast_glob_1.default)('**/*.html', { cwd: workspacePath, onlyFiles: true, deep: 6 });
         if (htmlFiles.length > 0) {
             // Check for server-template markers
@@ -108,11 +131,10 @@ async function validateWorkspace(config) {
             }
         }
         else if (framework === 'unknown') {
-            throw new Error('Babelize currently supports only React, Next.js, Vue, and plain HTML/CSS/JS projects. ' +
-                'No package.json or HTML files found.');
+            throw new Error(await unsupportedMessage(workspacePath, `Babelize supports ${SUPPORTED_LIST} projects. No package.json, manage.py or HTML files were found.`));
         }
     }
-    else if (framework === 'unknown') {
+    else if (framework === 'unknown' && packageJson) {
         framework = detectFramework(packageJson);
     }
     if (framework === 'unknown' && !isStatic) {
@@ -156,10 +178,16 @@ async function validateWorkspace(config) {
         }
     }
     if (!types_1.SUPPORTED_FRAMEWORKS.includes(framework)) {
-        throw new Error('Babelize currently supports only React, Next.js, Vue, and plain HTML/CSS/JS projects. ' +
-            'Other frameworks are not supported yet.');
+        throw new Error(await unsupportedMessage(workspacePath, `Babelize supports ${SUPPORTED_LIST} projects. This project's framework isn't supported yet.`));
+    }
+    if (framework === 'static') {
+        // A stray HTML file in a Rails/Laravel/Flutter repo doesn't make it a static site.
+        const stack = await (0, stack_1.detectStack)(await (0, stack_1.localRepoFiles)(workspacePath)).catch(() => null);
+        if (stack?.unsupported)
+            throw new Error(stack.message);
     }
-    const sourceDirs = await findSourceDirectories(workspacePath);
+    // Django: the whole project is scanned (templates/ and apps live anywhere).
+    const sourceDirs = framework === 'django' ? ['.'] : await findSourceDirectories(workspacePath);
     if (sourceDirs.length === 0) {
         logger_1.engineLogger.info('No standard source directories found, defaulting to root');
         sourceDirs.push('.');
@@ -168,16 +196,18 @@ async function validateWorkspace(config) {
     const localeFormat = frameworkConfig.localeFormat;
     const existingLocales = [];
     let hasLocalesDir = false;
+    let localeDirRel = '';
     if (localeFormat === 'po') {
-        // Django: check locale/<lang>/LC_MESSAGES/django.po structure
-        const djangoLocaleDir = path.join(workspacePath, 'locale');
+        // Django: <LOCALE_PATHS[0]>/<lang>/LC_MESSAGES/django.po (default <BASE_DIR>/locale)
+        localeDirRel = await (0, django_finalize_1.resolveDjangoLocaleDir)(workspacePath, djangoRoot ?? '.');
+        const djangoLocaleDir = path.join(workspacePath, localeDirRel);
         hasLocalesDir = await (0, file_utils_1.isDirectory)(djangoLocaleDir);
         if (hasLocalesDir) {
             const langDirs = await (0, file_utils_1.readDir)(djangoLocaleDir);
             for (const langDir of langDirs) {
                 const poFile = path.join(djangoLocaleDir, langDir, 'LC_MESSAGES', 'django.po');
                 if (await (0, file_utils_1.pathExists)(poFile)) {
-                    existingLocales.push(langDir);
+                    existingLocales.push((0, locale_names_1.localeFromDjangoName)(langDir));
                 }
             }
         }
@@ -208,6 +238,10 @@ async function validateWorkspace(config) {
         sourceDirs.push('.');
         publicDir = '.';
     }
+    if (localeFormat === 'po') {
+        // For gettext projects publicDir is the locale directory.
+        publicDir = localeDirRel;
+    }
     const babelizeDir = path.join(workspacePath, '.babelize');
     await (0, file_utils_1.ensureDir)(babelizeDir);
     const workspace = {
@@ -218,8 +252,9 @@ async function validateWorkspace(config) {
         hasLocalesDir,
         existingLocales,
         publicDir,
-        packageJson: packageJson,
+        packageJson: (packageJson ?? {}),
         formatConfig: config.formatConfig,
+        ...(framework === 'django' ? { djangoRoot: djangoRoot ?? '.' } : {}),
     };
     return { workspace };
 }

package/dist/orchestrator.d.ts

@@ -5,4 +5,9 @@ import type { EngineConfigV2, EngineResultV2 } from './runtime/types';
  * This is the single, clean wiring layer for the pipeline.
  * Workers/controllers call `runEngineV2()`.
  */
+/** Thrown at a progress checkpoint once the run's AbortSignal has fired. */
+export declare class RunAbortedError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
 export declare function runEngineV2(config: EngineConfigV2): Promise<EngineResultV2>;

package/dist/orchestrator.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunAbortedError = void 0;
 exports.runEngineV2 = runEngineV2;
 const fs = __importStar(require("fs-extra"));
 const logger_1 = require("./utils/logger");
@@ -43,6 +44,7 @@ const extract_1 = require("./modules/extractor/extract");
 const keygen_1 = require("./modules/keygen");
 const locale_builder_1 = require("./modules/locale-builder");
 const translate_1 = require("./modules/translator/translate");
+const glossary_1 = require("./modules/glossary");
 const translator_caller_1 = require("./utils/translator-caller");
 const injection_1 = require("./modules/injection");
 const summary_1 = require("./modules/summary");
@@ -54,13 +56,15 @@ const not_injected_1 = require("./utils/not-injected");
 const language_codes_1 = require("./modules/translator/language-codes");
 const format_injection_1 = require("./modules/format-injection");
 const extraction_options_1 = require("./utils/extraction-options");
+const catalog_1 = require("./django/catalog");
 /**
- * Whether the run's translator is an LLM (BYOK or an injected provider). The
- * NLLB service can't translate ICU plural messages. `capabilities.icu`
- * overrides the guess.
+ * Whether the run's translator is an LLM (BYOK or an injected provider that
+ * isn't plain-text MT). Only then do JSX sentences get ICU plurals in the
+ * source; NLLB translates existing ICU messages branch by branch.
+ * `capabilities.icu` overrides the guess.
  */
 function llmTranslator(config) {
-    return config.capabilities?.icu ?? (!!config.byok || !!config.providers?.translator);
+    return config.capabilities?.icu ?? (!!config.byok || (!!config.providers?.translator && !config.providers.translator.plainText));
 }
 /**
  * Engine v2 Orchestrator (backend runtime)
@@ -68,18 +72,54 @@ function llmTranslator(config) {
  * This is the single, clean wiring layer for the pipeline.
  * Workers/controllers call `runEngineV2()`.
  */
+/** Thrown at a progress checkpoint once the run's AbortSignal has fired. */
+class RunAbortedError extends Error {
+    constructor(reason) {
+        super(reason === 'timeout' ? 'Run timed out' : reason === 'cancelled' ? 'Run cancelled' : `Run aborted: ${reason}`);
+        this.reason = reason;
+        this.name = 'RunAbortedError';
+    }
+}
+exports.RunAbortedError = RunAbortedError;
+function abortReason(signal) {
+    const reason = signal.reason;
+    if (typeof reason === 'string')
+        return reason;
+    if (reason instanceof Error)
+        return reason.message;
+    return 'aborted';
+}
 async function runEngineV2(config) {
     if (config.logger) {
         const { logger, ...rest } = config;
         return (0, logger_1.runWithEngineLogger)(logger, () => runEngineV2(rest));
     }
     const startTime = Date.now();
+    // Fresh translations so far, for billing a run that is stopped mid-way.
+    const translationProgress = { freshTranslations: 0 };
     try {
         logger_1.engineLogger.info('Starting Babelize engine v2 pipeline', {
             workspacePath: config.workspacePath,
             targetLocales: config.targetLocales,
             dryRun: config.dryRun,
         });
+        // Cooperative cancellation: every phase (and every translation batch)
+        // reports progress, so the run stops at the next report after the signal
+        // fires. The engine has no other way to be stopped mid-run.
+        if (config.signal) {
+            const signal = config.signal;
+            const report = config.onProgress;
+            if (signal.aborted)
+                throw new RunAbortedError(abortReason(signal));
+            config = {
+                ...config,
+                onProgress: (message, step, status) => {
+                    if (signal.aborted)
+                        throw new RunAbortedError(abortReason(signal));
+                    report?.(message, step, status);
+                },
+            };
+        }
         // The file-list cache is per run: a long-lived worker (or a CLI rerun in
         // the same process) must see files added since the previous run.
         (0, file_utils_1.clearFindFilesCache)();
@@ -94,7 +134,7 @@ async function runEngineV2(config) {
         config.onProgress?.('Extracting strings from codebase...', 'extraction', 'running');
         // One resolved ICU decision for extraction, translation and injection (#248).
         const icuOptions = await (0, extraction_options_1.resolveIcuOptions)(workspace, llmTranslator(config));
-        if (!icuOptions.sentences) {
+        if (!icuOptions.sentences && workspace.framework !== 'django') {
             logger_1.engineLogger.warn('i18next-icu not loaded by the project i18n config; keeping JSX sentences as fragments');
         }
         const { extraction } = await (0, extract_1.extractStrings)(workspace, config.filesToProcess, icuOptions);
@@ -129,6 +169,11 @@ async function runEngineV2(config) {
         // Use only translatable strings for the rest of the pipeline
         config.onProgress?.('Generating translation keys...', 'keygen', 'running');
         const { keyGeneration } = (0, keygen_1.generateKeys)(translatableStrings, existingData);
+        // gettext projects (Django): the catalogue of messages and the project's
+        // existing .po translations, which are kept and never re-translated.
+        const gettext = workspace.localeFormat === 'po'
+            ? await catalog_1.GettextCatalog.create(workspace, translatableStrings, keyGeneration.keys, config.targetLocales)
+            : null;
         // ── Lockfile: partition keys ─────────────────────────────
         let lockfileStats = { reused: 0, translated: 0, changed: 0 };
         let tmHits = 0;
@@ -168,9 +213,20 @@ async function runEngineV2(config) {
             // is a heuristic (renamed translators, other file types, templates), so
             // it never changes what is translated, kept or written.
             keyUsage = await (0, key_usage_1.reportKeyUsage)(workspace, flatKeys, new Set(keyGeneration.keys.map((k) => k.key)));
+            // Translations already in the project's .po files win over the lockfile.
+            if (gettext)
+                lockfile = gettext.seedLockfile(lockfile, flatKeys);
             // Pseudo-localization (--provider pseudo) is not a translation: a real
             // run treats pseudo values in the lockfile as missing and translates them.
-            const lockfileRead = { pseudo: config.providers?.translator?.pseudo === true };
+            // The glossary is loaded once, here: keys whose glossary rules changed
+            // since their stored translation are re-translated (and only those).
+            // If the rules failed to load, stored translations are kept as they are
+            // rather than redone without the glossary.
+            const rules = await (0, translate_1.loadProjectTranslationRules)(config.projectId, config.providers?.rules);
+            const lockfileRead = {
+                pseudo: config.providers?.translator?.pseudo === true,
+                glossaryHash: rules.complete ? (source, locale) => (0, glossary_1.glossaryFingerprint)(source, locale, rules.glossary) : undefined,
+            };
             const partition = (0, lockfile_1.partitionKeys)(lockfile, flatKeys, config.targetLocales, lockfileRead);
             lockfileStats = (0, lockfile_1.computeLockfileStats)(partition);
             logger_1.engineLogger.info('Lockfile partition result', {
@@ -203,12 +259,18 @@ async function runEngineV2(config) {
             }
             else if (translatorHealthy) {
                 const keysToTranslateByLocale = (0, lockfile_1.buildKeysToTranslateByTargetLocale)(partition, config.targetLocales);
-                const result = await (0, translate_1.translateLocales)(workspace, localeHandling.sourceLocale, config.targetLocales, config.forceTranslation, config.dryRun, config.projectId, (msg) => config.onProgress?.(msg, 'translation', 'running'), keysToTranslateByLocale, config.providers?.cache, config.byok, contextMap, extractionContextMap, config.providers, { targetPlurals: icuOptions.targetPlurals });
+                const result = await (0, translate_1.translateLocales)(workspace, localeHandling.sourceLocale, config.targetLocales, config.forceTranslation, config.dryRun, config.projectId, (msg) => config.onProgress?.(msg, 'translation', 'running'), keysToTranslateByLocale, config.providers?.cache, config.byok, contextMap, extractionContextMap, config.providers, { targetPlurals: icuOptions.targetPlurals, pluralValuePlaceholders: gettext?.pluralValuePlaceholders(), rules, progress: translationProgress });
                 translation = result.translation;
+                // A translation that wouldn't compile into the .po file is a failure, not output.
+                gettext?.validate(translation, flatKeys);
                 tmHits = result.stats.tmHits;
                 translationMetadata = result.metadata;
                 translatedThisRun = freshTranslations(translation, translationMetadata);
-                assertSomethingTranslated(translation);
+                // Strings reused from the lockfile still make a good run: only fail
+                // when nothing at all is usable. Otherwise one string that keeps
+                // failing (and is retried every run) failed the whole project.
+                if (!hasCachedTranslations(cachedTranslations))
+                    assertSomethingTranslated(translation);
             }
             else {
                 const errorMsg = 'Translator service unavailable — target locale files (hi.json, fr.json, etc.) were NOT generated. Only source locale (en.json) was created. Check that TRANSLATOR_URL or BYOK provider is configured and the service is running.';
@@ -264,6 +326,15 @@ async function runEngineV2(config) {
                     locale.data._meta = { dir: (0, language_codes_1.isRTL)(locale.locale) ? 'rtl' : 'ltr', language: locale.locale };
                 }
             }
+            // The translator wrote only this run's strings to disk; write the merged
+            // locale (lockfile + new) so the workspace — which the download ZIP is
+            // built from — has every translation, including fully cached locales.
+            if (!config.dryRun && workspace.localeFormat !== 'po') {
+                for (const locale of translation.locales) {
+                    const { file } = (0, file_utils_1.localeFilePath)(workspace.path, workspace.publicDir, workspace.localeFormat, locale.locale);
+                    await (0, file_utils_1.writeJsonFile)(file, locale.data, true);
+                }
+            }
             // ── Lockfile: update after translation ─────────────────
             config.onProgress?.('Updating lockfile...', 'lockfile', 'running');
             const allTranslatedPerLocale = {};
@@ -333,7 +404,7 @@ async function runEngineV2(config) {
                 config, startTime, workspace, allTranslatedPerLocale,
                 lockfileStats, tmHits, translationMetadata,
                 translatedThisRun, keyUsage,
-                formatStrings, frameworkConfig,
+                formatStrings, frameworkConfig, gettext,
             });
             return result;
         }
@@ -358,7 +429,7 @@ async function runEngineV2(config) {
             config.onProgress?.(msg, 'translation', 'warning');
         }
         const translationResult = translatorHealthy
-            ? await (0, translate_1.translateLocales)(workspace, localeHandling.sourceLocale, config.targetLocales, config.forceTranslation, config.dryRun, config.projectId, (msg) => config.onProgress?.(msg, 'translation', 'running'), undefined, config.providers?.cache, config.byok, contextMap, extractionContextMap, config.providers, { targetPlurals: icuOptions.targetPlurals })
+            ? await (0, translate_1.translateLocales)(workspace, localeHandling.sourceLocale, config.targetLocales, config.forceTranslation, config.dryRun, config.projectId, (msg) => config.onProgress?.(msg, 'translation', 'running'), undefined, config.providers?.cache, config.byok, contextMap, extractionContextMap, config.providers, { targetPlurals: icuOptions.targetPlurals, pluralValuePlaceholders: gettext?.pluralValuePlaceholders(), progress: translationProgress })
             : {
                 translation: {
                     locales: [],
@@ -368,6 +439,7 @@ async function runEngineV2(config) {
                 metadata: {}
             };
         const translation = translationResult.translation;
+        gettext?.validate(translation, (0, keygen_1.flattenLocaleData)(localeHandling.sourceLocale.data));
         tmHits = translationResult.stats.tmHits;
         translationMetadata = translationResult.metadata;
         translatedThisRun = freshTranslations(translation, translationMetadata);
@@ -387,7 +459,7 @@ async function runEngineV2(config) {
             config, startTime, workspace, allTranslatedPerLocale,
             lockfileStats: undefined, tmHits, translationMetadata,
             translatedThisRun, keyUsage,
-            formatStrings, frameworkConfig,
+            formatStrings, frameworkConfig, gettext,
         });
         return result;
     }
@@ -396,6 +468,9 @@ async function runEngineV2(config) {
         return {
             success: false,
             error: error?.message ?? String(error),
+            ...(error instanceof RunAbortedError
+                ? { aborted: error.reason, partialTranslations: translationProgress.freshTranslations }
+                : {}),
             stats: {
                 filesScanned: 0,
                 filesWithStrings: 0,
@@ -510,6 +585,9 @@ function setNestedKey(obj, dottedKey, value) {
     }
     current[parts[parts.length - 1]] = value;
 }
+function hasCachedTranslations(cached) {
+    return Object.values(cached).some((locale) => Object.keys(locale).length > 0);
+}
 /**
  * A run where translation was needed but no string in any locale could be
  * translated is a failed run, not an empty success: fail it with the reasons
@@ -526,8 +604,24 @@ function assertSomethingTranslated(translation) {
     const sample = failures.find((f) => f.message)?.message;
     throw new Error(`No strings could be translated (${summary})${sample ? `: ${sample}` : ''}`);
 }
+/**
+ * Add a changed file to the run's list, folding a later write to a file that is
+ * already listed (an entry point that was injected, then wired up) into one
+ * entry: the original from the first write, the content from the last.
+ */
+function mergeChangedFile(list, changed) {
+    const existing = list.find((f) => f.file === changed.file);
+    if (!existing) {
+        list.push(changed);
+        return;
+    }
+    existing.modifiedContent = changed.modifiedContent;
+    existing.injections.push(...changed.injections);
+    existing.importAdded = existing.importAdded || changed.importAdded;
+    existing.hookAdded = existing.hookAdded || changed.hookAdded;
+}
 async function finalizePipeline(params) {
-    const { extraction, keyGeneration, localeHandling, translation, config, startTime, workspace, allTranslatedPerLocale, lockfileStats, tmHits, translationMetadata, formatStrings, frameworkConfig, translatedThisRun, keyUsage, } = params;
+    const { extraction, keyGeneration, localeHandling, translation, config, startTime, workspace, allTranslatedPerLocale, lockfileStats, tmHits, translationMetadata, formatStrings, frameworkConfig, translatedThisRun, keyUsage, gettext, } = params;
     const keyMapping = (0, keygen_1.createKeyMapping)(keyGeneration.keys);
     // Injection: AST-based i18n hook injection (skipped for frameworks like Django)
     let injection;
@@ -554,7 +648,8 @@ async function finalizePipeline(params) {
         config.onProgress?.('Injecting Intl.* format replacements...', 'injection', 'running');
         const formatInjection = await (0, format_injection_1.injectFormats)(workspace, formatStrings, config.formatConfig, config.dryRun);
         if (formatInjection.totalInjections > 0) {
-            injection.modifiedFiles.push(...formatInjection.modifiedFiles);
+            for (const changed of formatInjection.modifiedFiles)
+                mergeChangedFile(injection.modifiedFiles, changed);
             injection.totalInjections += formatInjection.totalInjections;
             injection.skippedFiles.push(...formatInjection.skippedFiles);
         }
@@ -562,8 +657,18 @@ async function finalizePipeline(params) {
             totalInjections: formatInjection.totalInjections,
         });
     }
-    // Finalization: install i18n deps, create config files, modify entry points
+    // gettext: merge this run's translations into the project's .po files.
     const finalizationNotes = [];
+    if (gettext) {
+        gettext.refreshReferences(injection);
+        const written = await gettext.write(config.targetLocales, allTranslatedPerLocale, {
+            dryRun: config.dryRun,
+            pseudo: config.providers?.translator?.pseudo === true,
+        });
+        translation.locales = written.locales;
+        finalizationNotes.push(...written.notes);
+    }
+    // Finalization: install i18n deps, create config files, modify entry points
     if (frameworkConfig.phases.includes('finalize')) {
         config.onProgress?.('Finalizing project...', 'finalization', 'running');
         const { finalization } = await (0, finalization_1.finalizeProject)(workspace, config.dryRun, {
@@ -572,6 +677,12 @@ async function finalizePipeline(params) {
             installDependencies: config.installDependencies,
         });
         finalizationNotes.push(...(finalization.warnings ?? []));
+        // Every file finalization wrote (package.json, i18n config, entry point,
+        // next.config, layout, i18n.js, settings.py, a lockfile it updated) ships
+        // with the run like injected files — hosts stage modifiedFiles for the PR.
+        for (const changed of finalization.changedFiles ?? []) {
+            mergeChangedFile(injection.modifiedFiles, { ...changed, injections: [], importAdded: false, hookAdded: false });
+        }
         if (finalization.dependenciesInvalid) {
             if (finalization.packagesInstalled) {
                 logger_1.engineLogger.info('New dependencies installed successfully');

package/dist/providers/types.d.ts

@@ -89,6 +89,13 @@ export interface TranslationProvider {
      * in the lockfile and replaced by the next real run.
      */
     readonly pseudo?: boolean;
+    /**
+     * Machine translation of plain text only (e.g. the NLLB service): it can't
+     * be given ICU syntax, prompts or hints. ICU plural/select messages are
+     * translated branch by branch for it, as for the default NLLB translator.
+     * Unset means an LLM-class provider.
+     */
+    readonly plainText?: boolean;
     /**
      * Translate a batch. Resolves with one KeyResult per requested entry.
      * Rejects only when the request as a whole failed (network, auth, 5xx) or
@@ -134,8 +141,9 @@ export interface EngineProviders {
     /**
      * Second chance for keys the (LLM) translator failed with `provider_error`
      * (rate limit, outage), tried once after the repair pass. Treated as a
-     * non-LLM service (e.g. NLLB): ICU and mixed-script keys are never sent to
-     * it, and its output isn't cached or written to translation memory. Keys it
+     * non-LLM service (e.g. NLLB): ICU keys go to it branch by branch,
+     * mixed-script keys never, and its output isn't cached or written to
+     * translation memory. Keys it
      * translated get `fallback: true` in their metadata.
      */
     fallbackTranslator?: TranslationProvider;

package/dist/qa/check-project.d.ts

@@ -12,7 +12,8 @@ export interface ProjectLocaleConfig {
 export declare function readProjectLocaleConfig(projectDir: string): Promise<ProjectLocaleConfig>;
 export interface LocaleSetReport {
     dir: string;
-    layout: LocaleFileSet['layout'];
+    /** `gettext`: Django .po catalogues (<dir>/<lang>/LC_MESSAGES/django.po). */
+    layout: LocaleFileSet['layout'] | 'gettext';
     sourceLocale: string;
     /** Source keys checked against. */
     sourceKeys: number;

package/dist/qa/check-project.js

@@ -44,6 +44,8 @@ const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const locale_qa_1 = require("./locale-qa");
 const locale_files_1 = require("./locale-files");
+const gettext_files_1 = require("./gettext-files");
+const locale_names_1 = require("../django/locale-names");
 /**
  * The parts of `.babelize/config.json` the local tools use. Missing or
  * malformed config is not an error: everything in it is optional.
@@ -65,19 +67,39 @@ async function readProjectLocaleConfig(projectDir) {
         targetLocales: list(raw.targetLocales) ?? list(raw.targetLanguageIds) ?? list(raw.targetLanguages),
     };
     const g = raw.glossary;
+    const neverTranslate = [];
+    const alwaysTranslateAs = [];
     if (g && typeof g === 'object') {
-        const neverTranslate = Array.isArray(g.neverTranslate) ? g.neverTranslate.filter((t) => typeof t === 'string') : [];
-        const alwaysTranslateAs = Array.isArray(g.alwaysTranslateAs)
-            ? g.alwaysTranslateAs.filter((e) => !!e && typeof e === 'object' && typeof e.term === 'string' &&
-                !!e.translations && typeof e.translations === 'object')
-            : [];
-        if (neverTranslate.length || alwaysTranslateAs.length)
-            config.glossary = { neverTranslate, alwaysTranslateAs };
+        if (Array.isArray(g.neverTranslate))
+            neverTranslate.push(...g.neverTranslate.filter((t) => typeof t === 'string'));
+        if (Array.isArray(g.alwaysTranslateAs)) {
+            alwaysTranslateAs.push(...g.alwaysTranslateAs.filter((e) => !!e && typeof e === 'object' && typeof e.term === 'string' &&
+                !!e.translations && typeof e.translations === 'object'));
+        }
+    }
+    // Older configs: `customTranslations: { term: { neverTranslate?, translations? } }`.
+    // Read into the same glossary so `translate` and `check` agree on it.
+    const legacy = raw.customTranslations;
+    if (legacy && typeof legacy === 'object' && !Array.isArray(legacy)) {
+        for (const [term, value] of Object.entries(legacy)) {
+            if (!value || typeof value !== 'object')
+                continue;
+            const entry = value;
+            if (entry.neverTranslate === true)
+                neverTranslate.push(term);
+            else if (entry.translations && typeof entry.translations === 'object') {
+                alwaysTranslateAs.push({ term, translations: entry.translations });
+            }
+        }
     }
+    if (neverTranslate.length || alwaysTranslateAs.length)
+        config.glossary = { neverTranslate, alwaysTranslateAs };
     return config;
 }
 /** The file a locale issue lives in, relative to the project root. */
 function localeIssueFile(set, issue) {
+    if (set.layout === 'gettext')
+        return `${set.dir === '.' ? '' : `${set.dir}/`}${(0, locale_names_1.djangoLocaleName)(issue.locale)}/LC_MESSAGES/django.po`;
     if (set.layout === 'namespaced') {
         const ns = issue.key.includes(':') ? issue.key.split(':')[0] : 'translation';
         return `${set.dir}/${issue.locale}/${ns}.json`;
@@ -146,5 +168,26 @@ async function checkProjectLocales(projectDir, options = {}) {
             fileErrors,
         });
     }
+    // gettext catalogues: the msgids are the source.
+    for (const set of await (0, gettext_files_1.findGettextSets)(projectDir, options.ignoreDirs)) {
+        const loaded = await (0, gettext_files_1.loadGettextSet)(projectDir, set);
+        const available = Object.keys(set.files).filter((l) => l !== sourceLocale).sort();
+        const wanted = options.locales?.length
+            ? options.locales.filter((l) => l !== sourceLocale)
+            : [...new Set([...available, ...expected])].filter((l) => l !== sourceLocale).sort();
+        const locales = [];
+        for (const locale of wanted.filter((l) => set.files[l])) {
+            locales.push((0, locale_qa_1.checkLocalePair)(loaded.source, loaded.byLocale[locale] ?? {}, locale, { sourceLocale, glossary, keys: options.keys }));
+        }
+        reports.push({
+            dir: set.dir,
+            layout: 'gettext',
+            sourceLocale,
+            sourceKeys: Object.keys(loaded.source).length,
+            locales,
+            missingLocales: wanted.filter((l) => !set.files[l]),
+            fileErrors: loaded.errors,
+        });
+    }
     return { sourceLocale, sets: reports, skippedSets };
 }

package/dist/qa/gettext-files.d.ts

@@ -0,0 +1,15 @@
+export interface GettextSet {
+    dir: string;
+    /** Babelize locale code → relative path of its django.po. */
+    files: Record<string, string>;
+}
+export interface GettextMessages {
+    source: Record<string, string>;
+    byLocale: Record<string, Record<string, string>>;
+    errors: Array<{
+        file: string;
+        message: string;
+    }>;
+}
+export declare function findGettextSets(projectDir: string, ignoreDirs?: readonly string[]): Promise<GettextSet[]>;
+export declare function loadGettextSet(projectDir: string, set: GettextSet): Promise<GettextMessages>;