@babelize/engine 0.1.0 → 0.1.3

package/dist/modules/glossary/index.d.ts

@@ -1,3 +1,2 @@
-export { applyGlossaryMask, restoreGlossaryMask } from './masker';
-export { applyAlwaysTranslateAs } from './glossary';
+export { canonicalLocale, canonicalizeLocaleKeys, conflictNotes, containsTerm, EMPTY_GLOSSARY, fixedTermsFor, glossaryFingerprint, hasFixedTerm, localeValue, normalizeGlossary, sourceHasTerm, termPattern, type GlossaryRuleInput, type GlossaryRules, } from './rules';
 export type { GlossaryEntry, GlossaryEntryType, BrandVoice, AlwaysTranslateAsEntry } from './types';

package/dist/modules/glossary/index.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyAlwaysTranslateAs = exports.restoreGlossaryMask = exports.applyGlossaryMask = void 0;
-var masker_1 = require("./masker");
-Object.defineProperty(exports, "applyGlossaryMask", { enumerable: true, get: function () { return masker_1.applyGlossaryMask; } });
-Object.defineProperty(exports, "restoreGlossaryMask", { enumerable: true, get: function () { return masker_1.restoreGlossaryMask; } });
-var glossary_1 = require("./glossary");
-Object.defineProperty(exports, "applyAlwaysTranslateAs", { enumerable: true, get: function () { return glossary_1.applyAlwaysTranslateAs; } });
+exports.termPattern = exports.sourceHasTerm = exports.normalizeGlossary = exports.localeValue = exports.hasFixedTerm = exports.glossaryFingerprint = exports.fixedTermsFor = exports.EMPTY_GLOSSARY = exports.containsTerm = exports.conflictNotes = exports.canonicalizeLocaleKeys = exports.canonicalLocale = void 0;
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "canonicalLocale", { enumerable: true, get: function () { return rules_1.canonicalLocale; } });
+Object.defineProperty(exports, "canonicalizeLocaleKeys", { enumerable: true, get: function () { return rules_1.canonicalizeLocaleKeys; } });
+Object.defineProperty(exports, "conflictNotes", { enumerable: true, get: function () { return rules_1.conflictNotes; } });
+Object.defineProperty(exports, "containsTerm", { enumerable: true, get: function () { return rules_1.containsTerm; } });
+Object.defineProperty(exports, "EMPTY_GLOSSARY", { enumerable: true, get: function () { return rules_1.EMPTY_GLOSSARY; } });
+Object.defineProperty(exports, "fixedTermsFor", { enumerable: true, get: function () { return rules_1.fixedTermsFor; } });
+Object.defineProperty(exports, "glossaryFingerprint", { enumerable: true, get: function () { return rules_1.glossaryFingerprint; } });
+Object.defineProperty(exports, "hasFixedTerm", { enumerable: true, get: function () { return rules_1.hasFixedTerm; } });
+Object.defineProperty(exports, "localeValue", { enumerable: true, get: function () { return rules_1.localeValue; } });
+Object.defineProperty(exports, "normalizeGlossary", { enumerable: true, get: function () { return rules_1.normalizeGlossary; } });
+Object.defineProperty(exports, "sourceHasTerm", { enumerable: true, get: function () { return rules_1.sourceHasTerm; } });
+Object.defineProperty(exports, "termPattern", { enumerable: true, get: function () { return rules_1.termPattern; } });

package/dist/modules/glossary/rules.d.ts

@@ -0,0 +1,81 @@
+import type { AlwaysTranslateAsEntry, GlossaryEntryType } from './types';
+/**
+ * Regex source matching `term` as a whole term: not preceded or followed by a
+ * letter, digit or underscore in any script ("Café" matches in "Café menu",
+ * "app" does not match in "apply" or "appé"). Use with the `u` flag.
+ */
+export declare function termPattern(term: string): string;
+/** Whether `text` contains `term` as a whole term, ignoring case. */
+export declare function containsTerm(text: string, term: string): boolean;
+/**
+ * The words of a source string a glossary rule can apply to: placeholders,
+ * tags, URLs, emails and code removed, and for an ICU message its argument
+ * names and selector keys too. "Open https://x.com/dashboard" has no
+ * "dashboard" a translator would translate. With `neverTranslate`, those
+ * terms are removed too: "Dashboard" in "Babelize Dashboard" (never
+ * translated) is not a use of a "Dashboard" rule.
+ */
+export declare function translatableText(source: string, neverTranslate?: readonly string[]): string;
+/**
+ * Whether a glossary term occurs in a source string's translatable text (see
+ * translatableText). Pass the never-translate terms when asking about an
+ * "always translate as" term: inside a never-translate term it doesn't count.
+ */
+export declare function sourceHasTerm(source: string, term: string, neverTranslate?: readonly string[]): boolean;
+/**
+ * BCP-47 casing for a locale code: `pt_br` / `PT-br` → `pt-BR`,
+ * `zh-hant` → `zh-Hant`, `es-419` stays. Anything that isn't
+ * language[-Script][-REGION] is returned trimmed, otherwise unchanged.
+ */
+export declare function canonicalLocale(code: string): string;
+/** Keys of a locale → value record in canonical form; on a clash the first key (in insertion order) wins. */
+export declare function canonicalizeLocaleKeys(record: Record<string, string> | null | undefined): Record<string, string>;
+/**
+ * The value for `locale` in a locale-keyed record: the exact locale (in any
+ * casing / separator), else its base language (`pt` serves `pt-BR`).
+ */
+export declare function localeValue(record: Record<string, string> | null | undefined, locale: string): string | undefined;
+export interface GlossaryRuleInput {
+    term: string;
+    type: GlossaryEntryType | string;
+    translations?: Record<string, string> | null;
+}
+/** A project's glossary after normalization: deduplicated, deterministic, conflicts resolved. */
+export interface GlossaryRules {
+    neverTranslate: string[];
+    alwaysTranslateAs: AlwaysTranslateAsEntry[];
+    /** Terms that had conflicting rules, with how the conflict was resolved (for QA notes). */
+    conflicts: Array<{
+        term: string;
+        message: string;
+    }>;
+}
+export declare const EMPTY_GLOSSARY: GlossaryRules;
+/**
+ * Normalize raw glossary entries. Terms match case-insensitively, so entries
+ * are grouped by lowercased term:
+ * - never-translate wins over always-translate-as for the same term (keeping
+ *   a term as-is can't corrupt the output; a translation for the wrong sense can);
+ * - several always-translate-as entries merge their locales (the first entry,
+ *   in term order, wins a locale they both define);
+ * - locale keys are canonicalized (`pt_br` → `pt-BR`).
+ * The result doesn't depend on the input order.
+ */
+export declare function normalizeGlossary(entries: GlossaryRuleInput[]): GlossaryRules;
+/** Always-translate-as terms with a translation for `locale` (exact, then base language). */
+export declare function fixedTermsFor(rules: GlossaryRules, locale: string): Array<{
+    term: string;
+    translation: string;
+}>;
+/** Whether `source` contains an always-translate-as term that has a translation for `locale`. */
+export declare function hasFixedTerm(source: string, rules: GlossaryRules, locale: string): boolean;
+/**
+ * Fingerprint of the glossary rules that shape `source`'s translation into
+ * `locale`: the never-translate terms it contains and the always-translate-as
+ * terms it contains with their translation for the locale. Empty when no rule
+ * applies, so adding a rule for an unrelated term changes nothing. Stored per
+ * locale in the lockfile: a key is re-translated when this changes.
+ */
+export declare function glossaryFingerprint(source: string, locale: string, rules: GlossaryRules): string;
+/** QA notes for conflicting rules whose term occurs in `source`. */
+export declare function conflictNotes(source: string, rules: GlossaryRules): string[];

package/dist/modules/glossary/rules.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_GLOSSARY = void 0;
+exports.termPattern = termPattern;
+exports.containsTerm = containsTerm;
+exports.translatableText = translatableText;
+exports.sourceHasTerm = sourceHasTerm;
+exports.canonicalLocale = canonicalLocale;
+exports.canonicalizeLocaleKeys = canonicalizeLocaleKeys;
+exports.localeValue = localeValue;
+exports.normalizeGlossary = normalizeGlossary;
+exports.fixedTermsFor = fixedTermsFor;
+exports.hasFixedTerm = hasFixedTerm;
+exports.glossaryFingerprint = glossaryFingerprint;
+exports.conflictNotes = conflictNotes;
+/**
+ * Project glossary rules, shared by the translate phase, locale QA, prompt
+ * hints and the CLI/MCP. One place decides how a term matches, which
+ * translation applies to a locale, and what happens when rules conflict.
+ */
+const crypto_1 = require("crypto");
+const placeholder_protection_1 = require("../../utils/placeholder-protection");
+const icu_message_1 = require("../../utils/icu-message");
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Regex source matching `term` as a whole term: not preceded or followed by a
+ * letter, digit or underscore in any script ("Café" matches in "Café menu",
+ * "app" does not match in "apply" or "appé"). Use with the `u` flag.
+ */
+function termPattern(term) {
+    return `(?<![\\p{L}\\p{N}_])${escapeRegex(term)}(?![\\p{L}\\p{N}_])`;
+}
+const termRegexes = new Map();
+/** Whether `text` contains `term` as a whole term, ignoring case. */
+function containsTerm(text, term) {
+    if (!term.trim())
+        return false;
+    // Cheap pre-check: most (key, term) pairs share nothing.
+    if (!text.toLowerCase().includes(term.toLowerCase())) {
+        // toLowerCase can change length for a few letters (İ); fall through only then.
+        if (text.length === text.toLowerCase().length && term.length === term.toLowerCase().length)
+            return false;
+    }
+    let re = termRegexes.get(term);
+    if (!re) {
+        if (termRegexes.size > 10000)
+            termRegexes.clear();
+        re = new RegExp(termPattern(term), 'iu');
+        termRegexes.set(term, re);
+    }
+    return re.test(text);
+}
+const NO_TERMS = [];
+/** Per never-translate list (by identity), source → translatable text. */
+const translatableCache = new WeakMap();
+/**
+ * The words of a source string a glossary rule can apply to: placeholders,
+ * tags, URLs, emails and code removed, and for an ICU message its argument
+ * names and selector keys too. "Open https://x.com/dashboard" has no
+ * "dashboard" a translator would translate. With `neverTranslate`, those
+ * terms are removed too: "Dashboard" in "Babelize Dashboard" (never
+ * translated) is not a use of a "Dashboard" rule.
+ */
+function translatableText(source, neverTranslate = NO_TERMS) {
+    let cache = translatableCache.get(neverTranslate);
+    if (!cache) {
+        cache = new Map();
+        translatableCache.set(neverTranslate, cache);
+    }
+    const hit = cache.get(source);
+    if (hit !== undefined)
+        return hit;
+    let text = (0, placeholder_protection_1.protectText)(source, [...neverTranslate]).text.replace(/\[#VAR_\d+#\]/g, ' ');
+    if ((0, icu_message_1.isIcuMessage)(source)) {
+        text = text
+            .replace(/\{\s*[\w.]+\s*,\s*(?:plural|select|selectordinal)\s*,(?:\s*offset\s*:\s*\d+)?/g, ' ')
+            .replace(/(?:=\d+|[\p{L}\p{N}_]+)\s*\{/gu, ' ');
+    }
+    if (cache.size > 20000)
+        cache.clear();
+    cache.set(source, text);
+    return text;
+}
+/**
+ * Whether a glossary term occurs in a source string's translatable text (see
+ * translatableText). Pass the never-translate terms when asking about an
+ * "always translate as" term: inside a never-translate term it doesn't count.
+ */
+function sourceHasTerm(source, term, neverTranslate = NO_TERMS) {
+    return containsTerm(translatableText(source, neverTranslate), term);
+}
+/**
+ * BCP-47 casing for a locale code: `pt_br` / `PT-br` → `pt-BR`,
+ * `zh-hant` → `zh-Hant`, `es-419` stays. Anything that isn't
+ * language[-Script][-REGION] is returned trimmed, otherwise unchanged.
+ */
+function canonicalLocale(code) {
+    const parts = code.trim().replace(/_/g, '-').split('-');
+    if (!/^[a-z]{2,3}$/i.test(parts[0] ?? ''))
+        return code.trim();
+    const out = [parts[0].toLowerCase()];
+    for (let i = 1; i < parts.length; i++) {
+        const p = parts[i];
+        if (/^[a-z]{4}$/i.test(p))
+            out.push(p.charAt(0).toUpperCase() + p.slice(1).toLowerCase());
+        else if (/^[a-z]{2}$/i.test(p))
+            out.push(p.toUpperCase());
+        else if (/^\d{3}$/.test(p))
+            out.push(p);
+        else
+            return code.trim();
+    }
+    return out.join('-');
+}
+/** Keys of a locale → value record in canonical form; on a clash the first key (in insertion order) wins. */
+function canonicalizeLocaleKeys(record) {
+    const out = {};
+    for (const [k, v] of Object.entries(record ?? {})) {
+        if (typeof v !== 'string' || !v.trim())
+            continue;
+        const key = canonicalLocale(k);
+        if (!(key in out))
+            out[key] = v;
+    }
+    return out;
+}
+/**
+ * The value for `locale` in a locale-keyed record: the exact locale (in any
+ * casing / separator), else its base language (`pt` serves `pt-BR`).
+ */
+function localeValue(record, locale) {
+    if (!record || !locale)
+        return undefined;
+    const want = canonicalLocale(locale);
+    let base;
+    const baseLang = want.split('-')[0];
+    for (const [k, v] of Object.entries(record)) {
+        if (typeof v !== 'string' || !v.trim())
+            continue;
+        const key = canonicalLocale(k);
+        if (key === want)
+            return v;
+        if (key === baseLang && base === undefined)
+            base = v;
+    }
+    return base;
+}
+exports.EMPTY_GLOSSARY = { neverTranslate: [], alwaysTranslateAs: [], conflicts: [] };
+/**
+ * Normalize raw glossary entries. Terms match case-insensitively, so entries
+ * are grouped by lowercased term:
+ * - never-translate wins over always-translate-as for the same term (keeping
+ *   a term as-is can't corrupt the output; a translation for the wrong sense can);
+ * - several always-translate-as entries merge their locales (the first entry,
+ *   in term order, wins a locale they both define);
+ * - locale keys are canonicalized (`pt_br` → `pt-BR`).
+ * The result doesn't depend on the input order.
+ */
+function normalizeGlossary(entries) {
+    const groups = new Map();
+    for (const e of entries) {
+        if (!e || typeof e.term !== 'string')
+            continue;
+        const term = e.term.trim();
+        if (!term)
+            continue;
+        if (e.type !== 'never_translate' && e.type !== 'always_translate_as')
+            continue;
+        const k = term.toLowerCase();
+        const list = groups.get(k) ?? [];
+        list.push({ ...e, term });
+        groups.set(k, list);
+    }
+    const neverTranslate = [];
+    const alwaysTranslateAs = [];
+    const conflicts = [];
+    const byTerm = (a, b) => (a.term < b.term ? -1 : a.term > b.term ? 1 : 0);
+    for (const k of [...groups.keys()].sort()) {
+        const list = groups.get(k).slice().sort(byTerm);
+        const never = list.filter((e) => e.type === 'never_translate');
+        const always = list.filter((e) => e.type === 'always_translate_as');
+        if (never.length > 0) {
+            neverTranslate.push(never[0].term);
+            if (always.length > 0) {
+                const names = [...new Set(list.map((e) => `"${e.term}"`))].join(' / ');
+                conflicts.push({
+                    term: never[0].term,
+                    message: `Glossary: ${names} is both "never translate" and "always translate as" (terms match ignoring case); "never translate" was applied`,
+                });
+            }
+            continue;
+        }
+        const translations = {};
+        for (const e of always) {
+            for (const [loc, v] of Object.entries(canonicalizeLocaleKeys(e.translations))) {
+                if (!(loc in translations))
+                    translations[loc] = v.trim();
+            }
+        }
+        alwaysTranslateAs.push({ term: always[0].term, type: 'always_translate_as', translations });
+    }
+    return { neverTranslate, alwaysTranslateAs, conflicts };
+}
+/** Always-translate-as terms with a translation for `locale` (exact, then base language). */
+function fixedTermsFor(rules, locale) {
+    const out = [];
+    for (const e of rules.alwaysTranslateAs) {
+        const translation = localeValue(e.translations, locale);
+        if (translation)
+            out.push({ term: e.term, translation });
+    }
+    return out;
+}
+/** Whether `source` contains an always-translate-as term that has a translation for `locale`. */
+function hasFixedTerm(source, rules, locale) {
+    return fixedTermsFor(rules, locale).some((g) => sourceHasTerm(source, g.term, rules.neverTranslate));
+}
+/**
+ * Fingerprint of the glossary rules that shape `source`'s translation into
+ * `locale`: the never-translate terms it contains and the always-translate-as
+ * terms it contains with their translation for the locale. Empty when no rule
+ * applies, so adding a rule for an unrelated term changes nothing. Stored per
+ * locale in the lockfile: a key is re-translated when this changes.
+ */
+function glossaryFingerprint(source, locale, rules) {
+    const parts = [];
+    for (const t of rules.neverTranslate) {
+        if (sourceHasTerm(source, t))
+            parts.push(`n\u0000${t.toLowerCase()}`);
+    }
+    for (const g of fixedTermsFor(rules, locale)) {
+        if (sourceHasTerm(source, g.term, rules.neverTranslate))
+            parts.push(`a\u0000${g.term.toLowerCase()}\u0000${g.translation}`);
+    }
+    if (parts.length === 0)
+        return '';
+    return (0, crypto_1.createHash)('sha256').update(parts.sort().join('\u0001'), 'utf8').digest('hex').slice(0, 16);
+}
+/** QA notes for conflicting rules whose term occurs in `source`. */
+function conflictNotes(source, rules) {
+    return rules.conflicts.filter((c) => sourceHasTerm(source, c.term)).map((c) => c.message);
+}

package/dist/modules/injection/inject.js

@@ -43,8 +43,7 @@ const StrategyFactory_1 = require("../../injection/StrategyFactory");
 const jsx_message_1 = require("../../utils/jsx-message");
 const module_constants_1 = require("../../utils/module-constants");
 const html_injector_1 = require("../../injection/html/html-injector");
-const django_template_injector_1 = require("../../injection/django/django-template-injector");
-const dtl_mask_1 = require("../../utils/dtl-mask");
+const inject_file_1 = require("../../django/inject-file");
 const types_2 = require("../../runtime/types");
 const file_utils_1 = require("../../utils/file-utils");
 const string_utils_1 = require("../../utils/string-utils");
@@ -296,34 +295,19 @@ positions) {
         try {
             const originalContent = await (0, file_utils_1.readFile)(filePath);
             let result;
-            if (relativePath.endsWith('.html') || relativePath.endsWith('.htm')) {
-                if (workspace.framework === 'django') {
-                    // Django: mask tags, run HTML injection, convert data-i18n to {% trans %}
-                    const { masked, restore } = (0, dtl_mask_1.maskTemplateTags)(originalContent);
-                    const maskedResult = await (0, html_injector_1.injectHtml)({
-                        content: masked,
-                        filePath: relativePath,
-                        keyMapping: fileKeys,
-                        injectSwitcher: false, // Django doesn't use JS switcher
-                    });
-                    result = await (0, django_template_injector_1.injectDjangoTemplates)({
-                        maskedContent: maskedResult.modifiedContent,
-                        restore,
-                        filePath: relativePath,
-                        keyMapping: fileKeys,
-                        sourceContent: originalContent,
-                    });
-                }
-                else {
-                    result = await (0, html_injector_1.injectHtml)({
-                        content: originalContent,
-                        filePath: relativePath,
-                        keyMapping: fileKeys,
-                        injectSwitcher: workspace.framework === 'static',
-                        targetLocales: workspace.existingLocales,
-                        sourceLocale: workspace.sourceDirs[0],
-                    });
-                }
+            if (workspace.framework === 'django') {
+                // Django: wrap hardcoded strings with gettext / {% translate %} in place.
+                result = (0, inject_file_1.injectDjangoFile)(originalContent, relativePath, fileKeys);
+            }
+            else if (relativePath.endsWith('.html') || relativePath.endsWith('.htm')) {
+                result = await (0, html_injector_1.injectHtml)({
+                    content: originalContent,
+                    filePath: relativePath,
+                    keyMapping: fileKeys,
+                    injectSwitcher: workspace.framework === 'static',
+                    targetLocales: workspace.existingLocales,
+                    sourceLocale: workspace.sourceDirs[0],
+                });
             }
             else if (relativePath.endsWith('.vue')) {
                 const existingDeps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };

package/dist/modules/keygen/keygen.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateKeys = generateKeys;
 const string_utils_1 = require("../../utils/string-utils");
 const jsx_message_1 = require("../../utils/jsx-message");
+const keys_1 = require("../../django/keys");
 function generateKeys(extractedStrings, existingKeys = {}) {
     const keys = [];
     const duplicates = [];
@@ -35,6 +36,12 @@ function generateKeys(extractedStrings, existingKeys = {}) {
     // The translation engine will only generate entries for categories the target locale needs.
     const pluralCategories = ['zero', 'one', 'two', 'few', 'many', 'other'];
     for (const extracted of extractedStrings) {
+        // gettext messages (Django) are looked up by their text; their keys are
+        // derived from the message, so they are stable without a source file.
+        if (extracted.gettext) {
+            keys.push(...(0, keys_1.gettextKeys)(extracted));
+            continue;
+        }
         const namespace = (0, string_utils_1.inferNamespace)(extracted.file);
         // A sentence message is named from its words: "Welcome back, {user}" → welcomeBack.
         const truncatedText = (0, string_utils_1.truncateForKey)(extracted.icuMessage ? (0, jsx_message_1.messageKeyText)(extracted.text) : extracted.text, 5);

package/dist/modules/locale-builder/locales.js

@@ -16,6 +16,8 @@ function assertSafeLocale(locale) {
 }
 async function handleBaseLocale(workspace, generatedKeys, sourceLocale = 'en', dryRun = false) {
     assertSafeLocale(sourceLocale);
+    if (workspace.localeFormat === 'po')
+        return gettextSourceLocale(generatedKeys, sourceLocale);
     const localePaths = (0, file_utils_1.localeFilePath)(workspace.path, workspace.publicDir, workspace.localeFormat, sourceLocale);
     const localesDir = localePaths.dir;
     const localeFilePathTarget = localePaths.file;
@@ -71,6 +73,24 @@ async function handleBaseLocale(workspace, generatedKeys, sourceLocale = 'en', d
         },
     };
 }
+/**
+ * gettext (Django): the source language has no catalogue file — the msgids
+ * in the code are the source text. The run's keys are the source locale.
+ */
+function gettextSourceLocale(generatedKeys, sourceLocale) {
+    const data = {};
+    for (const k of generatedKeys)
+        data[k.key] = k.value;
+    const sourceLocaleFile = {
+        locale: sourceLocale,
+        path: '',
+        data,
+        isNew: false,
+        isRTL: (0, language_codes_1.isRTL)(sourceLocale),
+        noFile: true,
+    };
+    return { localeHandling: { sourceLocale: sourceLocaleFile, newKeysCount: 0, existingKeysCount: Object.keys(data).length } };
+}
 function countKeys(data) {
     let count = 0;
     function traverse(obj) {
@@ -86,6 +106,9 @@ function countKeys(data) {
 }
 async function readLocaleFile(workspace, locale) {
     assertSafeLocale(locale);
+    // gettext projects have no source-locale file: the code is the catalogue.
+    if (workspace.localeFormat === 'po')
+        return null;
     if (workspace.localeFormat !== 'json') {
         throw new Error(`Locale format '${workspace.localeFormat}' reading not yet implemented`);
     }

package/dist/modules/lockfile/index.d.ts

@@ -1,3 +1,3 @@
 export { hashSourceString } from './hasher';
 export { type LockfileData, type LockfileEntry, type LockfilePartition, type LockfileStats, type PartitionedKey, createEmptyLockfile, } from './schema';
-export { buildKeysToTranslateByTargetLocale, clearLockfile, removeLocaleFromLockfile, collectCachedTranslations, computeLockfileStats, getLockfilePath, loadLockfile, partitionKeys, saveLockfile, updateLockfile, lockfileChanged, dropFailedTranslations, isStalePseudoEntry, type LockfileReadOptions, } from './lockfile-manager';
+export { buildKeysToTranslateByTargetLocale, clearLockfile, removeLocaleFromLockfile, collectCachedTranslations, computeLockfileStats, getLockfilePath, loadLockfile, partitionKeys, saveLockfile, updateLockfile, lockfileChanged, dropFailedTranslations, isStalePseudoEntry, glossaryChanged, type LockfileReadOptions, } from './lockfile-manager';

package/dist/modules/lockfile/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStalePseudoEntry = exports.dropFailedTranslations = exports.lockfileChanged = exports.updateLockfile = exports.saveLockfile = exports.partitionKeys = exports.loadLockfile = exports.getLockfilePath = exports.computeLockfileStats = exports.collectCachedTranslations = exports.removeLocaleFromLockfile = exports.clearLockfile = exports.buildKeysToTranslateByTargetLocale = exports.createEmptyLockfile = exports.hashSourceString = void 0;
+exports.glossaryChanged = exports.isStalePseudoEntry = exports.dropFailedTranslations = exports.lockfileChanged = exports.updateLockfile = exports.saveLockfile = exports.partitionKeys = exports.loadLockfile = exports.getLockfilePath = exports.computeLockfileStats = exports.collectCachedTranslations = exports.removeLocaleFromLockfile = exports.clearLockfile = exports.buildKeysToTranslateByTargetLocale = exports.createEmptyLockfile = exports.hashSourceString = void 0;
 var hasher_1 = require("./hasher");
 Object.defineProperty(exports, "hashSourceString", { enumerable: true, get: function () { return hasher_1.hashSourceString; } });
 var schema_1 = require("./schema");
@@ -19,3 +19,4 @@ Object.defineProperty(exports, "updateLockfile", { enumerable: true, get: functi
 Object.defineProperty(exports, "lockfileChanged", { enumerable: true, get: function () { return lockfile_manager_1.lockfileChanged; } });
 Object.defineProperty(exports, "dropFailedTranslations", { enumerable: true, get: function () { return lockfile_manager_1.dropFailedTranslations; } });
 Object.defineProperty(exports, "isStalePseudoEntry", { enumerable: true, get: function () { return lockfile_manager_1.isStalePseudoEntry; } });
+Object.defineProperty(exports, "glossaryChanged", { enumerable: true, get: function () { return lockfile_manager_1.glossaryChanged; } });

package/dist/modules/lockfile/lockfile-manager.d.ts

@@ -45,7 +45,16 @@ export declare function removeLocaleFromLockfile(projectId: string, localeCode:
 export interface LockfileReadOptions {
     /** This run is pseudo-localization: pseudo entries count as done. Otherwise they count as missing. */
     pseudo?: boolean;
+    /**
+     * The glossary fingerprint this run's rules give a key's source for a
+     * locale ('' when no rule applies). A stored translation made under a
+     * different fingerprint counts as missing, so glossary edits reach the
+     * keys they affect — and only those. Omit when the rules couldn't be loaded.
+     */
+    glossaryHash?: (source: string, locale: string) => string;
 }
+/** True when the glossary rules for this key and locale changed since its translation was stored. */
+export declare function glossaryChanged(entry: LockfileEntry, source: string, locale: string, options?: LockfileReadOptions): boolean;
 /**
  * True when the stored value for `locale` is pseudo-localization and this run
  * is a real one: it must be translated, never reused. Recognised by the

package/dist/modules/lockfile/lockfile-manager.js

@@ -39,6 +39,7 @@ exports.loadLockfile = loadLockfile;
 exports.saveLockfile = saveLockfile;
 exports.clearLockfile = clearLockfile;
 exports.removeLocaleFromLockfile = removeLocaleFromLockfile;
+exports.glossaryChanged = glossaryChanged;
 exports.isStalePseudoEntry = isStalePseudoEntry;
 exports.partitionKeys = partitionKeys;
 exports.dropFailedTranslations = dropFailedTranslations;
@@ -291,6 +292,15 @@ async function removeLocaleFromLockfile(projectId, localeCode, dataDir) {
         });
     }
 }
+/** True when the glossary rules for this key and locale changed since its translation was stored. */
+function glossaryChanged(entry, source, locale, options = {}) {
+    if (!options.glossaryHash)
+        return false;
+    const meta = entry.metadata?.[locale];
+    if (meta?.external)
+        return false;
+    return (meta?.glossaryHash ?? '') !== options.glossaryHash(source, locale);
+}
 /**
  * True when the stored value for `locale` is pseudo-localization and this run
  * is a real one: it must be translated, never reused. Recognised by the
@@ -323,7 +333,8 @@ function partitionKeys(lockfile, keys, targetLocales, options = {}) {
             continue;
         }
         // Hash matches — check if all target locales are present
-        const missing = targetLocales.filter((locale) => !(locale in entry.languages) || isStalePseudoEntry(entry, locale, options));
+        const missing = targetLocales.filter((locale) => !(locale in entry.languages) || isStalePseudoEntry(entry, locale, options) ||
+            glossaryChanged(entry, value, locale, options));
         if (missing.length === 0) {
             // Fully translated and unchanged
             result.unchanged.push({ key, value });
@@ -379,6 +390,10 @@ function pickLockfileMetadata(meta) {
         out.sourceHash = meta.sourceHash;
     if (typeof meta.inTm === 'boolean')
         out.inTm = meta.inTm;
+    if (typeof meta.glossaryHash === 'string' && meta.glossaryHash)
+        out.glossaryHash = meta.glossaryHash;
+    if (meta.external === true)
+        out.external = true;
     return out;
 }
 function sameJson(a, b) {