@babelize/engine 0.0.0-stage → 0.1.0

package/dist/modules/format-injection/index.js

@@ -0,0 +1,272 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectFormats = injectFormats;
+exports.partitionFormatStrings = partitionFormatStrings;
+const path = __importStar(require("path"));
+const t = __importStar(require("@babel/types"));
+const inject_formats_1 = require("./inject-formats");
+const ast_helpers_1 = require("../../utils/ast-helpers");
+const file_utils_1 = require("../../utils/file-utils");
+const types_1 = require("../../runtime/types");
+const generator_1 = require("@babel/generator");
+/**
+ * Run format injection for all format strings.
+ *
+ * Replaces hardcoded currency, date, and number values in source files
+ * with Intl.* API calls (e.g., Intl.NumberFormat, Intl.DateTimeFormat).
+ */
+async function injectFormats(workspace, formatStrings, formatConfig, dryRun = false) {
+    const modifiedFiles = [];
+    const skippedFiles = [];
+    let totalInjections = 0;
+    if (!formatConfig.enabled || formatStrings.length === 0) {
+        return { modifiedFiles, skippedFiles, totalInjections: 0 };
+    }
+    // Group format strings by file
+    const stringsByFile = new Map();
+    for (const s of formatStrings) {
+        if (!s.detectedFormat)
+            continue;
+        const fileKey = s.file;
+        if (!stringsByFile.has(fileKey)) {
+            stringsByFile.set(fileKey, []);
+        }
+        stringsByFile.get(fileKey).push(s);
+    }
+    // Build locale expression based on framework
+    const localeExpr = (0, inject_formats_1.buildLocaleExpression)(workspace.framework || 'unknown');
+    // Find all source files
+    const sourceFiles = [];
+    for (const sourceDir of workspace.sourceDirs) {
+        const dirPath = path.join(workspace.path, sourceDir);
+        const files = await (0, file_utils_1.findFiles)(dirPath, types_1.SUPPORTED_EXTENSIONS, types_1.EXCLUDED_PATTERNS);
+        sourceFiles.push(...files);
+    }
+    // Build a lookup of format strings by (relative file path, line)
+    const formatStringLookup = new Map();
+    for (const [fileKey, strings] of stringsByFile) {
+        const lineMap = new Map();
+        for (const s of strings) {
+            lineMap.set(s.line, s);
+        }
+        formatStringLookup.set(fileKey, lineMap);
+    }
+    // Process each file
+    for (const filePath of sourceFiles) {
+        const relativePath = (0, file_utils_1.getRelativePath)(workspace.path, filePath);
+        const fileStrings = stringsByFile.get(relativePath);
+        if (!fileStrings || fileStrings.length === 0)
+            continue;
+        try {
+            const originalContent = await (0, file_utils_1.readFile)(filePath);
+            const isTypeScript = filePath.endsWith('.ts') || filePath.endsWith('.tsx');
+            const ast = (0, ast_helpers_1.parseCode)(originalContent, { isTypeScript });
+            const injections = [];
+            const lineLookup = formatStringLookup.get(relativePath);
+            if (!lineLookup)
+                continue;
+            // Walk AST and replace matching string literals with Intl.* expressions
+            (0, ast_helpers_1.traverse)(ast, {
+                StringLiteral(strPath) {
+                    const node = strPath.node;
+                    if (!node.loc)
+                        return;
+                    const line = node.loc.start.line;
+                    const formatStr = lineLookup.get(line);
+                    if (!formatStr || !formatStr.detectedFormat)
+                        return;
+                    // Verify the text matches exactly (avoid false positives from partial matches)
+                    if (node.value !== formatStr.text)
+                        return;
+                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, localeExpr);
+                    if (!astExpr) {
+                        skippedFiles.push({
+                            file: relativePath,
+                            reason: 'format-ast-build-failed',
+                            details: `Could not build AST for: "${formatStr.text}"`,
+                        });
+                        return;
+                    }
+                    strPath.replaceWith(astExpr);
+                    const replacementCode = (0, generator_1.generate)(astExpr).code;
+                    injections.push({
+                        file: relativePath,
+                        line,
+                        column: node.loc.start.column,
+                        original: formatStr.text,
+                        replacement: replacementCode,
+                        key: '',
+                        confidence: 100,
+                        formatClass: formatStr.detectedFormat.class,
+                    });
+                },
+                JSXText(jsxPath) {
+                    const node = jsxPath.node;
+                    if (!node.loc)
+                        return;
+                    const line = node.loc.start.line;
+                    const formatStr = lineLookup.get(line);
+                    if (!formatStr || !formatStr.detectedFormat)
+                        return;
+                    const text = node.value.trim();
+                    if (!text)
+                        return;
+                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, localeExpr);
+                    if (!astExpr) {
+                        skippedFiles.push({
+                            file: relativePath,
+                            reason: 'format-ast-build-failed',
+                            details: `Could not build AST for: "${formatStr.text}"`,
+                        });
+                        return;
+                    }
+                    const exprContainer = t.jsxExpressionContainer(astExpr);
+                    jsxPath.replaceWith(exprContainer);
+                    const replacementCode = (0, generator_1.generate)(astExpr).code;
+                    injections.push({
+                        file: relativePath,
+                        line,
+                        column: node.loc.start.column,
+                        original: formatStr.text,
+                        replacement: replacementCode,
+                        key: '',
+                        confidence: 100,
+                        formatClass: formatStr.detectedFormat.class,
+                    });
+                },
+            });
+            if (injections.length === 0)
+                continue;
+            const modifiedContent = (0, ast_helpers_1.generateCode)(ast, originalContent);
+            if (!dryRun) {
+                await (0, file_utils_1.writeFile)(filePath, modifiedContent);
+            }
+            modifiedFiles.push({
+                file: relativePath,
+                originalContent,
+                modifiedContent,
+                injections,
+                importAdded: false,
+                hookAdded: false,
+            });
+            totalInjections += injections.length;
+        }
+        catch (error) {
+            skippedFiles.push({
+                file: relativePath,
+                reason: 'parse-error',
+                details: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Process HTML files with regex-based format injection
+    const htmlExtensions = ['.html', '.htm'];
+    for (const sourceDir of workspace.sourceDirs) {
+        const dirPath = path.join(workspace.path, sourceDir);
+        const files = await (0, file_utils_1.findFiles)(dirPath, htmlExtensions, types_1.EXCLUDED_PATTERNS);
+        for (const filePath of files) {
+            const relativePath = (0, file_utils_1.getRelativePath)(workspace.path, filePath);
+            const fileStrings = stringsByFile.get(relativePath);
+            if (!fileStrings || fileStrings.length === 0)
+                continue;
+            try {
+                let content = await (0, file_utils_1.readFile)(filePath);
+                const injections = [];
+                for (const formatStr of fileStrings) {
+                    if (!formatStr.detectedFormat)
+                        continue;
+                    const escaped = formatStr.text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    const regex = new RegExp(escaped, 'g');
+                    if (!regex.test(content))
+                        continue;
+                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, localeExpr);
+                    if (!astExpr)
+                        continue;
+                    const replacementCode = (0, generator_1.generate)(astExpr).code;
+                    content = content.replace(regex, replacementCode);
+                    injections.push({
+                        file: relativePath,
+                        line: formatStr.line,
+                        column: 0,
+                        original: formatStr.text,
+                        replacement: replacementCode,
+                        key: '',
+                        confidence: 100,
+                        formatClass: formatStr.detectedFormat.class,
+                    });
+                }
+                if (injections.length === 0)
+                    continue;
+                if (!dryRun)
+                    await (0, file_utils_1.writeFile)(filePath, content);
+                modifiedFiles.push({
+                    file: relativePath,
+                    originalContent: await (0, file_utils_1.readFile)(filePath).catch(() => ''),
+                    modifiedContent: content,
+                    injections,
+                    importAdded: false,
+                    hookAdded: false,
+                });
+                totalInjections += injections.length;
+            }
+            catch (error) {
+                skippedFiles.push({
+                    file: relativePath,
+                    reason: 'parse-error',
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    return { modifiedFiles, skippedFiles, totalInjections };
+}
+/**
+ * Filter format strings out of an array of extracted strings.
+ * Returns [translatableStrings, formatStrings].
+ */
+function partitionFormatStrings(strings) {
+    const translatable = [];
+    const format = [];
+    for (const s of strings) {
+        if (s.context === 'format-string' && s.detectedFormat) {
+            format.push(s);
+        }
+        else {
+            translatable.push(s);
+        }
+    }
+    return [translatable, format];
+}

package/dist/modules/format-injection/inject-formats.d.ts

@@ -0,0 +1,31 @@
+import * as t from '@babel/types';
+import type { FormatLocaleConfig } from '@babelize/types';
+import type { DetectedFormat, ExtractedString } from '../../runtime/types';
+/**
+ * Generate the Intl.* API call string that replaces a hardcoded format value.
+ *
+ * Examples:
+ *   "$1,234.56" → `new Intl.NumberFormat(locale, { style: 'currency', currency: 'USD' }).format(1234.56)`
+ *   "01/15/2024" → `new Intl.DateTimeFormat(locale, { month: '2-digit', day: '2-digit', year: 'numeric' }).format(new Date(2024, 0, 15))`
+ *   "1,234.56" → `new Intl.NumberFormat(locale).format(1234.56)`
+ */
+export declare function generateFormatExpression(format: DetectedFormat, formatConfig: FormatLocaleConfig): string | null;
+/**
+ * Given a locale and DetectedFormat, return both the Intl.* expression
+ * and a getTranslationKey-compatible fallback string.
+ */
+export interface FormatInjection {
+    expression: string;
+    fallback: string;
+}
+export declare function buildFormatInjection(extracted: ExtractedString, formatConfig: FormatLocaleConfig): FormatInjection | null;
+/**
+ * Build a Babel AST Expression node for the Intl.* call that replaces
+ * a hardcoded format value. The localeExpr parameter provides the runtime
+ * locale expression (e.g., i18n.language, navigator.language).
+ */
+export declare function buildFormatAstExpression(format: DetectedFormat, formatConfig: FormatLocaleConfig, localeExpr: t.Expression): t.Expression | null;
+/**
+ * Build a locale expression based on the detected framework.
+ */
+export declare function buildLocaleExpression(framework: string): t.Expression;

package/dist/modules/format-injection/inject-formats.js

@@ -0,0 +1,208 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFormatExpression = generateFormatExpression;
+exports.buildFormatInjection = buildFormatInjection;
+exports.buildFormatAstExpression = buildFormatAstExpression;
+exports.buildLocaleExpression = buildLocaleExpression;
+const t = __importStar(require("@babel/types"));
+/**
+ * Generate the Intl.* API call string that replaces a hardcoded format value.
+ *
+ * Examples:
+ *   "$1,234.56" → `new Intl.NumberFormat(locale, { style: 'currency', currency: 'USD' }).format(1234.56)`
+ *   "01/15/2024" → `new Intl.DateTimeFormat(locale, { month: '2-digit', day: '2-digit', year: 'numeric' }).format(new Date(2024, 0, 15))`
+ *   "1,234.56" → `new Intl.NumberFormat(locale).format(1234.56)`
+ */
+function generateFormatExpression(format, formatConfig) {
+    switch (format.class) {
+        case 'currency':
+            return generateCurrencyExpression(format, formatConfig);
+        case 'date':
+            return generateDateExpression(format, formatConfig);
+        case 'number':
+            return generateNumberExpression(format, formatConfig);
+        default:
+            return null;
+    }
+}
+function generateCurrencyExpression(format, formatConfig) {
+    const currencyCode = format.detectedCurrency || formatConfig.currency?.code || 'USD';
+    const numericValue = parseNumericValue(format.rawValue);
+    if (isNaN(numericValue)) {
+        return JSON.stringify(format.originalString);
+    }
+    return `new Intl.NumberFormat(locale, { style: 'currency', currency: '${currencyCode}' }).format(${numericValue})`;
+}
+function generateDateExpression(format, _formatConfig) {
+    const date = parseDateValue(format.rawValue, format.dateSource);
+    if (!date) {
+        return JSON.stringify(format.originalString);
+    }
+    const dateOptions = format.dateOptions || { year: 'numeric', month: '2-digit', day: '2-digit' };
+    const dateOptionsStr = JSON.stringify(dateOptions);
+    return `new Intl.DateTimeFormat(locale, ${dateOptionsStr}).format(new Date(${date.getTime()}))`;
+}
+function generateNumberExpression(format, _formatConfig) {
+    const numericValue = parseNumericValue(format.rawValue);
+    if (isNaN(numericValue)) {
+        return JSON.stringify(format.originalString);
+    }
+    const options = { ...format.numberOptions };
+    return `new Intl.NumberFormat(locale, ${JSON.stringify(options)}).format(${numericValue})`;
+}
+function parseNumericValue(rawValue) {
+    const cleaned = rawValue.replace(/[^0-9.,-]/g, '');
+    const normalized = cleaned.replace(/,/g, '');
+    return parseFloat(normalized);
+}
+function parseDateValue(rawValue, source) {
+    // Remove ordinal suffixes like "th", "nd", "st", "rd"
+    const cleaned = rawValue.replace(/(\d+)(st|nd|rd|th)/, '$1');
+    switch (source) {
+        case 'MM/DD/YYYY': {
+            const parts = cleaned.split(/[/]/);
+            if (parts.length !== 3)
+                return null;
+            return new Date(parseInt(parts[2]), parseInt(parts[0]) - 1, parseInt(parts[1]));
+        }
+        case 'DD/MM/YYYY': {
+            const parts = cleaned.split(/[/]/);
+            if (parts.length !== 3)
+                return null;
+            return new Date(parseInt(parts[2]), parseInt(parts[1]) - 1, parseInt(parts[0]));
+        }
+        case 'YYYY-MM-DD': {
+            const parts = cleaned.split(/[-/]/);
+            if (parts.length !== 3)
+                return null;
+            return new Date(parseInt(parts[0]), parseInt(parts[1]) - 1, parseInt(parts[2]));
+        }
+        case 'DD.MM.YYYY': {
+            const parts = cleaned.split('.');
+            if (parts.length !== 3)
+                return null;
+            return new Date(parseInt(parts[2]), parseInt(parts[1]) - 1, parseInt(parts[0]));
+        }
+        case 'MMM DD, YYYY': {
+            return new Date(cleaned);
+        }
+        case 'DD MMM YYYY': {
+            return new Date(cleaned);
+        }
+        default: {
+            return new Date(cleaned);
+        }
+    }
+}
+function buildFormatInjection(extracted, formatConfig) {
+    if (!extracted.detectedFormat)
+        return null;
+    const expression = generateFormatExpression(extracted.detectedFormat, formatConfig);
+    if (!expression)
+        return null;
+    return {
+        expression,
+        fallback: extracted.text,
+    };
+}
+/**
+ * Build a Babel AST Expression node for the Intl.* call that replaces
+ * a hardcoded format value. The localeExpr parameter provides the runtime
+ * locale expression (e.g., i18n.language, navigator.language).
+ */
+function buildFormatAstExpression(format, formatConfig, localeExpr) {
+    switch (format.class) {
+        case 'currency':
+            return buildCurrencyAstExpression(format, formatConfig, localeExpr);
+        case 'date':
+            return buildDateAstExpression(format, localeExpr);
+        case 'number':
+            return buildNumberAstExpression(format, localeExpr);
+        default:
+            return null;
+    }
+}
+function buildCurrencyAstExpression(format, formatConfig, localeExpr) {
+    const currencyCode = format.detectedCurrency || formatConfig.currency?.code || 'USD';
+    const numericValue = parseNumericValue(format.rawValue);
+    if (isNaN(numericValue))
+        return null;
+    const intlCallee = t.memberExpression(t.identifier('Intl'), t.identifier('NumberFormat'));
+    const options = t.objectExpression([
+        t.objectProperty(t.identifier('style'), t.stringLiteral('currency')),
+        t.objectProperty(t.identifier('currency'), t.stringLiteral(currencyCode)),
+    ]);
+    const nfNew = t.newExpression(intlCallee, [localeExpr, options]);
+    return t.callExpression(t.memberExpression(nfNew, t.identifier('format')), [t.numericLiteral(numericValue)]);
+}
+function buildDateAstExpression(format, localeExpr) {
+    const date = parseDateValue(format.rawValue, format.dateSource);
+    if (!date)
+        return null;
+    const dateOptions = format.dateOptions || { year: 'numeric', month: '2-digit', day: '2-digit' };
+    const props = Object.entries(dateOptions).map(([key, val]) => t.objectProperty(t.identifier(key), t.stringLiteral(val)));
+    const intlCallee = t.memberExpression(t.identifier('Intl'), t.identifier('DateTimeFormat'));
+    const dtfNew = t.newExpression(intlCallee, [localeExpr, t.objectExpression(props)]);
+    const dateArg = t.newExpression(t.identifier('Date'), [t.numericLiteral(date.getTime())]);
+    return t.callExpression(t.memberExpression(dtfNew, t.identifier('format')), [dateArg]);
+}
+function buildNumberAstExpression(format, localeExpr) {
+    const numericValue = parseNumericValue(format.rawValue);
+    if (isNaN(numericValue))
+        return null;
+    const intlCallee = t.memberExpression(t.identifier('Intl'), t.identifier('NumberFormat'));
+    const args = [localeExpr];
+    const options = { ...format.numberOptions };
+    if (Object.keys(options).length > 0) {
+        const props = Object.entries(options).map(([key, val]) => t.objectProperty(t.identifier(key), t.numericLiteral(val)));
+        args.push(t.objectExpression(props));
+    }
+    const nfNew = t.newExpression(intlCallee, args);
+    return t.callExpression(t.memberExpression(nfNew, t.identifier('format')), [t.numericLiteral(numericValue)]);
+}
+/**
+ * Build a locale expression based on the detected framework.
+ */
+function buildLocaleExpression(framework) {
+    switch (framework) {
+        case 'react-i18next':
+            return t.memberExpression(t.identifier('i18n'), t.identifier('language'));
+        case 'next-intl':
+            return t.callExpression(t.identifier('useLocale'), []);
+        default:
+            return t.logicalExpression('||', t.memberExpression(t.identifier('navigator'), t.identifier('language')), t.stringLiteral('en-US'));
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { AlwaysTranslateAsEntry } from './types';
+/**
+ * Post-translation processor for "always translate as" glossary entries.
+ *
+ * After the HF model returns a translation, this function scans the result
+ * for each always-translate-as term and replaces it with the fixed
+ * translation for the target locale.
+ */
+export declare function applyAlwaysTranslateAs(translatedText: string, entries: AlwaysTranslateAsEntry[], targetLocale: string): string;

package/dist/modules/glossary/glossary.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAlwaysTranslateAs = applyAlwaysTranslateAs;
+const string_utils_1 = require("../../utils/string-utils");
+/**
+ * Post-translation processor for "always translate as" glossary entries.
+ *
+ * After the HF model returns a translation, this function scans the result
+ * for each always-translate-as term and replaces it with the fixed
+ * translation for the target locale.
+ */
+function applyAlwaysTranslateAs(translatedText, entries, targetLocale) {
+    if (!entries.length || !translatedText)
+        return translatedText;
+    let result = translatedText;
+    // Sort longest-first to avoid partial replacements
+    const sorted = [...entries].sort((a, b) => b.term.length - a.term.length);
+    for (const entry of sorted) {
+        const fixedTranslation = entry.translations[targetLocale];
+        if (!fixedTranslation)
+            continue;
+        // Replace all occurrences of the term (case-insensitive, word-boundary)
+        const regex = new RegExp(`\\b${(0, string_utils_1.escapeRegex)(entry.term)}\\b`, 'gi');
+        result = result.replace(regex, fixedTranslation);
+    }
+    return result;
+}

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

@@ -0,0 +1,3 @@
+export { applyGlossaryMask, restoreGlossaryMask } from './masker';
+export { applyAlwaysTranslateAs } from './glossary';
+export type { GlossaryEntry, GlossaryEntryType, BrandVoice, AlwaysTranslateAsEntry } from './types';

package/dist/modules/glossary/index.js

@@ -0,0 +1,8 @@
+"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; } });

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

@@ -0,0 +1,23 @@
+export interface MaskedString {
+    masked: string;
+    terms: MaskedTerm[];
+}
+export interface MaskedTerm {
+    term: string;
+    matches: string[];
+}
+/**
+ * Replace never-translate terms with placeholders (__TERM_0__, __TERM_1__, ...)
+ * so NLLB does not attempt to translate them.
+ *
+ * Rules:
+ * - Whole-word matching only (word-boundary anchors)
+ * - Case-insensitive matching
+ * - Longest terms matched first to prevent partial overlaps
+ * - All occurrences of each term are masked
+ */
+export declare function applyGlossaryMask(text: string, terms: string[]): MaskedString;
+/**
+ * Restore __TERM_N__ placeholders back to their original terms.
+ */
+export declare function restoreGlossaryMask(text: string, terms: MaskedTerm[]): string;

package/dist/modules/glossary/masker.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyGlossaryMask = applyGlossaryMask;
+exports.restoreGlossaryMask = restoreGlossaryMask;
+const string_utils_1 = require("../../utils/string-utils");
+/**
+ * Replace never-translate terms with placeholders (__TERM_0__, __TERM_1__, ...)
+ * so NLLB does not attempt to translate them.
+ *
+ * Rules:
+ * - Whole-word matching only (word-boundary anchors)
+ * - Case-insensitive matching
+ * - Longest terms matched first to prevent partial overlaps
+ * - All occurrences of each term are masked
+ */
+function applyGlossaryMask(text, terms) {
+    if (!terms.length || !text) {
+        return { masked: text, terms: [] };
+    }
+    // Sort terms longest-first to avoid smaller terms eating larger ones.
+    const sorted = [...terms].sort((a, b) => b.length - a.length);
+    let masked = text;
+    const usedTerms = [];
+    sorted.forEach((term) => {
+        let placeholderIndex = usedTerms.findIndex((entry) => entry.term === term);
+        if (placeholderIndex === -1) {
+            placeholderIndex = usedTerms.push({ term, matches: [] }) - 1;
+        }
+        const placeholder = `__TERM_${placeholderIndex}__`;
+        // Word-boundary + case-insensitive matching
+        const regex = new RegExp(`(?:^|(?<=\\W))${(0, string_utils_1.escapeRegex)(term)}(?:$|(?=\\W))`, 'gi');
+        masked = masked.replace(regex, (matched) => {
+            usedTerms[placeholderIndex].matches.push(matched);
+            return placeholder;
+        });
+    });
+    return { masked, terms: usedTerms };
+}
+/**
+ * Restore __TERM_N__ placeholders back to their original terms.
+ */
+function restoreGlossaryMask(text, terms) {
+    if (!terms.length || !text)
+        return text;
+    let restored = text;
+    terms.forEach((maskedTerm, index) => {
+        const placeholderRegex = new RegExp(`__TERM_${index}__`, 'g');
+        let replacementIndex = 0;
+        restored = restored.replace(placeholderRegex, () => {
+            const replacement = maskedTerm.matches[replacementIndex] ?? maskedTerm.term;
+            replacementIndex++;
+            return replacement;
+        });
+    });
+    return restored;
+}

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

@@ -0,0 +1,22 @@
+export type GlossaryEntryType = 'never_translate' | 'always_translate_as';
+export interface GlossaryEntry {
+    id?: string;
+    project_id: string;
+    term: string;
+    type: GlossaryEntryType;
+    /** For always_translate_as: locale code → fixed translation */
+    translations?: Record<string, string>;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface BrandVoice {
+    name: string;
+    description?: string;
+    guidelines?: string[];
+}
+/** Subset used by the masker and translation pipeline */
+export interface AlwaysTranslateAsEntry {
+    term: string;
+    type: 'always_translate_as';
+    translations: Record<string, string>;
+}

package/dist/modules/glossary/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export { injectTranslations, checkIdempotency } from './inject';