@babelize/engine 0.1.0 → 0.1.3

package/dist/qa/gettext-files.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findGettextSets = findGettextSets;
+exports.loadGettextSet = loadGettextSet;
+/**
+ * Django/gettext catalogues for the locale checks: every
+ * `<locale dir>/<lang>/LC_MESSAGES/django.po` set. gettext has no source
+ * file — the msgids are the source text — so the source side of a check is
+ * the set's msgids. Fuzzy and empty entries count as missing (Django ignores
+ * them at runtime).
+ */
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const po_file_1 = require("../django/po-file");
+const locale_names_1 = require("../django/locale-names");
+const locale_files_1 = require("./locale-files");
+async function findGettextSets(projectDir, ignoreDirs = locale_files_1.DEFAULT_LOCALE_IGNORE_DIRS) {
+    const found = await (0, fast_glob_1.default)('**/*/LC_MESSAGES/django.po', {
+        cwd: projectDir,
+        ignore: [...ignoreDirs, 'venv', '.venv', 'site-packages'].map((d) => `**/${d}/**`),
+        onlyFiles: true,
+        deep: 8,
+        followSymbolicLinks: false,
+    });
+    const sets = new Map();
+    for (const rel of found.sort()) {
+        const parts = rel.split('/');
+        const langDir = parts[parts.length - 3];
+        const locale = (0, locale_names_1.localeFromDjangoName)(langDir);
+        if (!(0, locale_files_1.isLocaleCode)(locale))
+            continue;
+        const dir = parts.slice(0, -3).join('/') || '.';
+        const set = sets.get(dir) ?? { dir, files: {} };
+        set.files[locale] = rel;
+        sets.set(dir, set);
+    }
+    return [...sets.values()];
+}
+/** Message key for a catalogue entry in check reports. */
+function messageKey(msgctxt, msgid) {
+    return msgctxt !== undefined ? `${msgctxt}|${msgid}` : msgid;
+}
+async function loadGettextSet(projectDir, set) {
+    const source = {};
+    const byLocale = {};
+    const errors = [];
+    for (const [locale, rel] of Object.entries(set.files)) {
+        const messages = {};
+        byLocale[locale] = messages;
+        let content;
+        try {
+            content = await fs_1.promises.readFile(path.join(projectDir, rel), 'utf8');
+        }
+        catch (err) {
+            errors.push({ file: rel, message: err.message });
+            continue;
+        }
+        let po;
+        try {
+            po = (0, po_file_1.parsePo)(content);
+        }
+        catch (err) {
+            errors.push({ file: rel, message: `invalid PO file: ${err.message}` });
+            continue;
+        }
+        for (const e of po.entries) {
+            if (e.obsolete)
+                continue;
+            const key = messageKey(e.msgctxt, e.msgid);
+            // Plural entries are checked through their plural form (it carries the count placeholder).
+            source[key] = e.msgidPlural ?? e.msgid;
+            if (e.flags.includes('fuzzy') || e.msgstr.length === 0 || e.msgstr.some((s) => !s))
+                continue;
+            messages[key] = e.msgstr[e.msgstr.length - 1];
+        }
+    }
+    return { source, byLocale, errors };
+}

package/dist/qa/locale-qa.js

@@ -16,6 +16,7 @@ exports.tallyLocaleIssues = tallyLocaleIssues;
  */
 const icu_message_1 = require("../utils/icu-message");
 const glossary_match_1 = require("../utils/glossary-match");
+const rules_1 = require("../modules/glossary/rules");
 const placeholder_protection_1 = require("../utils/placeholder-protection");
 const pseudo_markers_1 = require("../utils/pseudo-markers");
 const icu_spans_1 = require("../utils/icu-spans");
@@ -49,6 +50,17 @@ function language(locale) {
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/** The glossary as the translate phase applies it for `locale`. */
+function resolveGlossary(glossary, locale) {
+    const rules = (0, rules_1.normalizeGlossary)([
+        ...(glossary.neverTranslate ?? []).map((term) => ({ term, type: 'never_translate' })),
+        ...(glossary.alwaysTranslateAs ?? []).map((e) => ({ term: e.term, type: 'always_translate_as', translations: e.translations })),
+    ]);
+    return {
+        neverTranslate: rules.neverTranslate,
+        alwaysTranslateAs: (0, rules_1.fixedTermsFor)(rules, locale).map((g) => ({ term: g.term, translations: { [locale]: g.translation } })),
+    };
+}
 function containsTerm(text, term, ignoreCase) {
     return new RegExp(`(?<![\\p{L}\\p{N}_])${escapeRegex(term)}(?![\\p{L}\\p{N}_])`, ignoreCase ? 'iu' : 'u').test(text);
 }
@@ -201,16 +213,17 @@ function checkValue(key, source, target, locale, options, push, plural) {
         });
     }
     for (const term of neverTranslate) {
-        if (term.trim() && containsTerm(source, term, false) && !containsTerm(target, term, false)) {
+        if (term.trim() && (0, rules_1.sourceHasTerm)(source, term) && !containsTerm(target, term, true)) {
             push({ key, code: 'glossary_violation', severity: 'warning', message: `"${term}" must stay untranslated but is missing from the translation.` });
         }
     }
     for (const entry of options.glossary?.alwaysTranslateAs ?? []) {
-        const expected = entry.translations[locale] ?? entry.translations[language(locale)];
+        // resolveGlossary left only this locale's translation (exact, else base language).
+        const expected = (0, rules_1.localeValue)(entry.translations, locale);
         if (!expected || !entry.term.trim())
             continue;
         // Same matcher as the translate phase: inflected forms count (Polish "obszaru roboczego").
-        if (containsTerm(source, entry.term, true) && !(0, glossary_match_1.containsGlossaryTranslation)(target, expected)) {
+        if ((0, rules_1.sourceHasTerm)(source, entry.term, neverTranslate) && !(0, glossary_match_1.containsGlossaryTranslation)(target, expected)) {
             push({ key, code: 'glossary_violation', severity: 'warning', message: `"${entry.term}" should be translated as "${expected}".` });
         }
     }
@@ -234,6 +247,10 @@ function pluralGroups(flat) {
  * warnings mixed; callers cap and sort as they need.
  */
 function checkLocalePair(source, target, locale, options = {}) {
+    // Resolved the way the translate phase resolves it (case-insensitive
+    // terms, never-translate wins a conflict), so QA expects what translation does.
+    if (options.glossary)
+        options = { ...options, glossary: resolveGlossary(options.glossary, locale) };
     const issues = [];
     const push = (issue) => issues.push({ locale, ...issue });
     const only = options.keys ? new Set(options.keys) : null;

package/dist/runtime/config.js

@@ -25,6 +25,7 @@ function validateEngineConfigV2(config) {
         dryRun: config.dryRun ?? false,
         forceTranslation: config.forceTranslation ?? false,
         onProgress: config.onProgress,
+        signal: config.signal,
         projectId: config.projectId,
         filesToProcess: config.filesToProcess,
         byok: config.byok,

package/dist/runtime/types.d.ts

@@ -35,6 +35,13 @@ export interface EngineConfigV2 {
     dataDir?: string;
     /** Logger for this run only (default: the one set with setEngineLogger). */
     logger?: EngineLogger;
+    /**
+     * Stops the run cooperatively: checked at every progress report, so the
+     * pipeline ends at the next phase or translation batch after it fires. The
+     * result then has `aborted` set to the signal's reason (e.g. 'cancelled',
+     * 'timeout').
+     */
+    signal?: AbortSignal;
     /** Callback for progress updates */
     onProgress?: (message: string, step?: string, status?: 'running' | 'success' | 'error' | 'warning') => void;
     /**
@@ -83,6 +90,12 @@ export interface WorkspaceInfo {
     packageJson?: Record<string, any>;
     /** Output locale file format (e.g., 'json' for React, 'po' for Django) */
     localeFormat: 'json' | 'po' | 'arb';
+    /**
+     * Django: the project root (the directory holding manage.py, i.e. BASE_DIR),
+     * relative to the workspace. For gettext projects `publicDir` is the locale
+     * directory (LOCALE_PATHS), relative to the workspace.
+     */
+    djangoRoot?: string;
     /** Format localization config propagated from EngineConfigV2 */
     formatConfig?: FormatLocaleConfig;
     /** Static HTML runtime options propagated from EngineConfigV2 */
@@ -132,6 +145,27 @@ export interface ExtractedString {
      * exactly these nodes (not others with the same text on the same line).
      */
     offsets?: number[];
+    /**
+     * gettext message (Django): `text` is the msgid. Keys are derived from the
+     * message itself, and the PO catalogue — not a key — is what code looks up.
+     */
+    gettext?: GettextInfo;
+}
+export interface GettextInfo {
+    msgid: string;
+    msgidPlural?: string;
+    msgctxt?: string;
+    /** PO flags (python-format, python-brace-format). */
+    flags: string[];
+    /** Translator comments from the code (`# Translators: …`). */
+    comments: string[];
+    /** Already marked in the code (gettext call / trans tag); otherwise the injector wraps it. */
+    wrapped: boolean;
+    /**
+     * Translate a plural message as one ICU plural (an LLM can produce every
+     * CLDR category); otherwise singular and plural are translated separately.
+     */
+    icu?: boolean;
 }
 export interface ExtractionResult {
     strings: ExtractedString[];
@@ -150,6 +184,10 @@ export interface GeneratedKey {
     pluralCategory?: 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
     parentContext?: string;
     extractionContext?: string;
+    /** gettext message this key translates, and which part of it (Django). */
+    gettext?: GettextInfo & {
+        form: 'single' | 'icu' | 'singular' | 'plural';
+    };
 }
 export interface KeyGenerationResult {
     keys: GeneratedKey[];
@@ -167,6 +205,22 @@ export interface LocaleFile {
     data: LocaleData;
     isNew: boolean;
     isRTL?: boolean;
+    /**
+     * Exact file content to write at `path` (e.g. a merged .po catalogue).
+     * When set, hosts write this instead of serializing `data` as JSON.
+     */
+    content?: string;
+    /**
+     * There is no file for this locale (the source language of a gettext
+     * project: the code itself is the catalogue). Hosts write nothing.
+     */
+    noFile?: boolean;
+    /** Further files generated for this locale (e.g. a compiled .mo next to the .po). */
+    extraFiles?: Array<{
+        path: string;
+        content: string;
+        encoding: 'utf8' | 'base64';
+    }>;
 }
 export interface LocaleHandlingResult {
     sourceLocale: LocaleFile;
@@ -222,6 +276,8 @@ export interface FileInjection {
     injections: InjectionLocation[];
     importAdded: boolean;
     hookAdded: boolean;
+    /** The run created this file (it was not in the project before), e.g. a generated i18n config. */
+    created?: boolean;
 }
 export interface InjectionResult {
     modifiedFiles: FileInjection[];
@@ -297,6 +353,14 @@ export interface KeyUsageReport {
 export interface EngineResultV2 {
     success: boolean;
     error?: string;
+    /** Set when the run was stopped through `signal`: the abort reason. */
+    aborted?: string;
+    /**
+     * Only with `aborted`: strings freshly translated (and written to the
+     * translation cache and TM) before the stop. A later run reuses them for
+     * free, so the caller bills them rather than refunding the whole run.
+     */
+    partialTranslations?: number;
     /**
      * Keys that could not be translated, per locale, with the reason. They are
      * absent from the locale files and the lockfile, so the next run retries

package/dist/utils/extraction-options.d.ts

@@ -13,11 +13,17 @@ export interface ResolvedIcuOptions {
      * with i18next-icu. Not vue-i18n, the vanilla runtime or static HTML.
      */
     icuRuntime: boolean;
-    /** A translation may add an ICU plural over a count (`{files} files`): ICU runtime + LLM translator. */
+    /**
+     * A translation may add an ICU plural over a count (`{files} files`): ICU
+     * runtime. An LLM writes the plural; for NLLB it is built branch by branch.
+     */
     targetPlurals: boolean;
 }
 /**
- * @param llm the run's translator is an LLM (BYOK or an injected provider);
- *            the NLLB service can't translate ICU plural messages.
+ * @param llm the run's translator is an LLM (BYOK or an injected provider).
+ *            Only then do JSX sentences get ICU plurals in the source (that
+ *            changes the source messages, and the sync check must agree).
+ *            Translating ICU works with every translator: NLLB gets it
+ *            branch by branch.
  */
 export declare function resolveIcuOptions(workspace: WorkspaceInfo, llm: boolean): Promise<ResolvedIcuOptions>;

package/dist/utils/extraction-options.js

@@ -4,10 +4,20 @@ exports.resolveIcuOptions = resolveIcuOptions;
 const StrategyFactory_1 = require("../injection/StrategyFactory");
 const i18next_icu_1 = require("./i18next-icu");
 /**
- * @param llm the run's translator is an LLM (BYOK or an injected provider);
- *            the NLLB service can't translate ICU plural messages.
+ * @param llm the run's translator is an LLM (BYOK or an injected provider).
+ *            Only then do JSX sentences get ICU plurals in the source (that
+ *            changes the source messages, and the sync check must agree).
+ *            Translating ICU works with every translator: NLLB gets it
+ *            branch by branch.
  */
 async function resolveIcuOptions(workspace, llm) {
+    if (workspace.framework === 'django') {
+        // gettext has its own plural forms (msgstr[n]). A plural message is
+        // translated as one ICU plural (an LLM whole, NLLB branch by branch with
+        // a number of each category) and mapped onto them. The keys are internal:
+        // the project's source never gains ICU.
+        return { sentences: false, plurals: true, icuRuntime: false, targetPlurals: false };
+    }
     const deps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };
     const strategy = ['react', 'nextjs'].includes(workspace.framework) ? StrategyFactory_1.StrategyFactory.getStrategy(workspace.framework, deps).id : 'other';
     let icuRuntime = false;
@@ -19,5 +29,5 @@ async function resolveIcuOptions(workspace, llm) {
         icuRuntime = (await (0, i18next_icu_1.detectI18nextIcu)(workspace)).available;
         sentences = icuRuntime;
     }
-    return { sentences, plurals: icuRuntime && llm, icuRuntime, targetPlurals: icuRuntime && llm };
+    return { sentences, plurals: icuRuntime && llm, icuRuntime, targetPlurals: icuRuntime };
 }

package/dist/utils/file-utils.js

@@ -52,6 +52,7 @@ exports.concurrentMap = concurrentMap;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const string_utils_1 = require("./string-utils");
+const locale_names_1 = require("../django/locale-names");
 /**
  * Engine v2 file utils.
  *
@@ -203,9 +204,13 @@ function localeExtension(format) {
  */
 function localeFilePath(workspacePath, publicDir, localeFormat, targetLocale) {
     if (localeFormat === 'po') {
-        const dir = path.join(workspacePath, 'locale', targetLocale, 'LC_MESSAGES');
+        // publicDir is the locale directory (LOCALE_PATHS) for gettext projects;
+        // Django names locale directories pt_BR, zh_Hans, …
+        const localeDir = publicDir && publicDir !== 'public' ? publicDir : 'locale';
+        const name = (0, locale_names_1.djangoLocaleName)(targetLocale);
+        const dir = path.join(workspacePath, localeDir, name, 'LC_MESSAGES');
         const file = path.join(dir, 'django.po');
-        const relativeFile = path.join('locale', targetLocale, 'LC_MESSAGES', 'django.po');
+        const relativeFile = path.join(localeDir, name, 'LC_MESSAGES', 'django.po');
         return { dir, file, relativeFile };
     }
     const ext = localeExtension(localeFormat);

package/dist/utils/icu-message.d.ts

@@ -38,8 +38,8 @@ export interface IcuIssue {
 /**
  * Compare a translated ICU message to its source. Errors mean the message is
  * broken at runtime (unparseable, arguments renamed, select branches changed,
- * no `other`). Missing target plural categories are only a warning: ICU
- * falls back to `other` for them.
+ * no `other`, a target plural category whole numbers use). A missing category
+ * only fractions use is a warning: ICU falls back to `other` for it.
  */
 export declare function compareIcuMessages(source: string, translated: string, targetLocale: string, options?: {
     /**

package/dist/utils/icu-message.js

@@ -190,11 +190,29 @@ function pluralCategories(locale, type) {
         return [...CLDR_ORDER];
     }
 }
+/**
+ * Whole numbers (0–999) a plural category is used for, e.g. Czech few → 2, 3, 4,
+ * Czech many → none (only fractions like 1.5). CLDR integer rules repeat
+ * within every hundred, so this range covers them.
+ */
+function integersOf(locale, type, category) {
+    try {
+        const rules = new Intl.PluralRules(locale, { type });
+        const out = [];
+        for (let n = 0; n < 1000; n++)
+            if (rules.select(n) === category)
+                out.push(n);
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Compare a translated ICU message to its source. Errors mean the message is
  * broken at runtime (unparseable, arguments renamed, select branches changed,
- * no `other`). Missing target plural categories are only a warning: ICU
- * falls back to `other` for them.
+ * no `other`, a target plural category whole numbers use). A missing category
+ * only fractions use is a warning: ICU falls back to `other` for it.
  */
 function compareIcuMessages(source, translated, targetLocale, options = {}) {
     let sourceAst;
@@ -291,11 +309,29 @@ function compareIcuMessages(source, translated, targetLocale, options = {}) {
         }
         const missing = allowed.filter((c) => !target.keys.includes(c));
         if (missing.length) {
-            issues.push({
-                severity: 'warning',
-                code: 'icu_plural_category_missing',
-                message: `{${target.name}, ${target.kind}} has no [${missing.join(', ')}] branch for ${targetLocale}; "other" will be used`,
-            });
+            // A missing category whole numbers reach (Czech few: 2–4) shows the
+            // wrong form for common counts ("2 souborů"): an error. One only
+            // fractions reach (Czech many: 1.5), or whose numbers all have `=n`
+            // branches, falls back to `other` rarely: a warning.
+            const type = target.kind === 'selectordinal' ? 'ordinal' : 'cardinal';
+            const reached = missing
+                .map((c) => ({ c, ns: integersOf(targetLocale, type, c).filter((n) => !target.keys.includes(`=${n}`)) }))
+                .filter((m) => m.ns.length > 0);
+            if (reached.length) {
+                const examples = (ns) => `${ns.slice(0, 3).join(', ')}${ns.length > 3 ? ', …' : ''}`;
+                issues.push({
+                    severity: 'error',
+                    code: 'icu_plural_category_missing',
+                    message: `{${target.name}, ${target.kind}} has no ${reached.map((m) => `${m.c} branch (${examples(m.ns)})`).join(', ')} for ${targetLocale}; those counts would get the "other" form`,
+                });
+            }
+            else {
+                issues.push({
+                    severity: 'warning',
+                    code: 'icu_plural_category_missing',
+                    message: `{${target.name}, ${target.kind}} has no [${missing.join(', ')}] branch for ${targetLocale}; "other" will be used`,
+                });
+            }
         }
     }
     return issues;

package/dist/utils/jsx-message.js

@@ -432,6 +432,13 @@ function buildJsxMessage(node, options = {}) {
     if (!(0, string_utils_1.isTranslatableText)(literal) || (0, string_utils_1.containsPII)(literal))
         return { kind: 'none' };
     const meaningful = pieces.filter((p) => p.type !== 'text' || p.value.trim() !== '');
+    // Sibling elements with nothing between them (nav links, a row of buttons)
+    // are separate strings, not one sentence: grouping them made
+    // "<link>Shop</link><link2>Your cart</link2>…", which can't be split for
+    // translators and loses its tags in machine translation. A sentence needs
+    // words or a value outside the inline elements.
+    if (!meaningful.some((p) => p.type !== 'tag'))
+        return { kind: 'none' };
     const isSentence = placeholderCount + tagCount > 0 && (meaningful.length >= 2 || placeholderCount > 0);
     if (!isSentence)
         return { kind: 'none' };

package/dist/utils/metadata.d.ts

@@ -33,14 +33,16 @@ export interface BabelizeConfig {
     excludePatterns: string[];
     customTranslations: Record<string, Record<string, string>>;
 }
-export type FrameworkType = 'react' | 'nextjs' | 'vue' | 'angular' | 'svelte' | 'astro' | 'remix' | 'gatsby' | 'nuxt' | 'static' | 'unknown';
-export type PackageManagerType = 'npm' | 'yarn' | 'pnpm' | 'bun';
+export type FrameworkType = 'react' | 'nextjs' | 'vue' | 'angular' | 'svelte' | 'astro' | 'remix' | 'gatsby' | 'nuxt' | 'static' | 'django' | 'unknown';
+export type PackageManagerType = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'pip' | 'poetry' | 'pipenv' | 'uv' | 'pdm';
 export interface ProjectInfo {
     framework: FrameworkType;
     frameworks?: FrameworkType[];
     frameworkVersion?: string;
     packageManager: PackageManagerType | 'unknown';
     packageManagers: PackageManagerType[];
+    /** Set when the project is built with something Babelize doesn't support yet, e.g. "Laravel". */
+    unsupportedFramework?: string;
     nodeVersion?: string;
     projectVersion?: string;
     projectName?: string;

package/dist/utils/metadata.js

@@ -38,9 +38,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBabelizeDir = getBabelizeDir;
 exports.ensureBabelizeDir = ensureBabelizeDir;
@@ -57,8 +54,8 @@ exports.detectProjectInfo = detectProjectInfo;
 exports.getProjectInfo = getProjectInfo;
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
-const fast_glob_1 = __importDefault(require("fast-glob"));
 const logger_1 = require("./logger");
+const stack_1 = require("../detection/stack");
 const DEFAULT_CONFIG = {
     sourceLocale: 'en',
     targetLocales: [],
@@ -205,15 +202,23 @@ async function detectProjectInfo(workspacePath) {
             }
         }
     }
+    let packageManagers = detectPackageManagers(workspacePath);
+    let unsupportedFramework;
     if (primaryFramework === 'unknown' && frameworks.length === 0) {
-        const htmlFiles = await (0, fast_glob_1.default)('**/*.html', { cwd: workspacePath, onlyFiles: true, deep: 3 });
-        if (htmlFiles.length > 0) {
-            primaryFramework = 'static';
-            frameworks.push('static');
-            logger_1.engineLogger.info('Detected static HTML/CSS/JS project', { workspacePath });
+        // No JS framework: Django, a static site, or a stack Babelize doesn't support.
+        const stack = await (0, stack_1.detectStack)(await (0, stack_1.localRepoFiles)(workspacePath)).catch(() => null);
+        if (stack?.framework === 'django' || stack?.framework === 'static') {
+            primaryFramework = stack.framework;
+            frameworks.push(stack.framework);
+            packageManagers = stack.packageManagers;
+            logger_1.engineLogger.info('Detected project framework', { workspacePath, framework: stack.framework });
+        }
+        else if (stack) {
+            unsupportedFramework = stack.unsupported?.name;
+            if (stack.packageManagers.length)
+                packageManagers = stack.packageManagers;
         }
     }
-    const packageManagers = detectPackageManagers(workspacePath);
     const primaryPackageManager = packageManagers.length > 0 ? packageManagers[0] : 'unknown';
     const projectInfo = {
         framework: primaryFramework,
@@ -221,6 +226,7 @@ async function detectProjectInfo(workspacePath) {
         frameworkVersion,
         packageManager: primaryPackageManager,
         packageManagers,
+        ...(unsupportedFramework ? { unsupportedFramework } : {}),
         projectVersion: packageJson.version,
         projectName: packageJson.name,
         dependencies: {

package/dist/utils/not-injected.js

@@ -17,6 +17,8 @@ function findNotInjected(keyGeneration, injection) {
     for (const k of keyGeneration.keys) {
         if (k.isPlural)
             continue; // the base key stands for its plural forms
+        if (k.gettext?.wrapped)
+            continue; // already marked in the code (gettext call / trans tag)
         const file = k.extractionId.split(':')[0];
         const id = `${file}\u0000${k.key}`;
         if (injected.has(id) || seen.has(id))

package/dist/utils/placeholder-protection.d.ts

@@ -17,6 +17,16 @@ export interface ProtectedText {
     text: string;
     /** Original text of each token, by index: tokens[i] is what `[#VAR_i#]` stands for. */
     tokens: string[];
+    /**
+     * What each token is restored to: the original text, except for a glossary
+     * "always translate as" term, which is restored to its fixed translation.
+     */
+    restore: string[];
+}
+/** A term protected as a token and restored to a fixed translation ("always translate as"). */
+export interface FixedTerm {
+    term: string;
+    translation: string;
 }
 export interface TokenCheck {
     ok: boolean;
@@ -31,15 +41,22 @@ export interface TokenCheck {
  * Replace every protected span (and every never-translate term) with a token.
  * With `icu: true`, braces are left alone (they are ICU structure) and only
  * URLs, emails, code, tags and terms are tokenized.
+ * `fixedTerms` ("always translate as") are tokenized too, and `restore` maps
+ * their tokens to the fixed translation: a plain-text translator never sees
+ * the term, so it can't ignore the rule.
  * Literal `[#VAR_n#]` text already present in the source is protected too, so
  * it can never be confused with an issued token.
  */
 export declare function protectText(text: string, neverTranslateTerms?: string[], options?: {
     icu?: boolean;
+    fixedTerms?: FixedTerm[];
 }): ProtectedText;
 /** Every issued token must appear exactly once, and no other token may appear. */
 export declare function checkTokens(translated: string, tokenCount: number): TokenCheck;
-/** Swap tokens back for their original text. Call only after checkTokens passed. */
+/**
+ * Swap tokens back. Pass protectText's `restore` (fixed glossary terms become
+ * their translation) or `tokens` (original text). Call only after checkTokens passed.
+ */
 export declare function restoreText(translated: string, tokens: string[]): string;
 /**
  * True when nothing translatable is left once protected spans are removed —