@babelize/engine 0.0.0-stage → 0.1.2

package/dist/utils/circuit-breaker.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Circuit Breaker Pattern
+ *
+ * Prevents cascading failures by stopping requests to failing services
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = exports.CircuitState = void 0;
+exports.getCircuitBreaker = getCircuitBreaker;
+var CircuitState;
+(function (CircuitState) {
+    CircuitState["CLOSED"] = "closed";
+    CircuitState["OPEN"] = "open";
+    CircuitState["HALF_OPEN"] = "half-open";
+})(CircuitState || (exports.CircuitState = CircuitState = {}));
+class CircuitBreaker {
+    constructor(name, options = {
+        failureThreshold: 5,
+        resetTimeout: 60000, // 1 minute
+        halfOpenMaxCalls: 3,
+    }) {
+        this.name = name;
+        this.options = options;
+        this.state = CircuitState.CLOSED;
+        this.failureCount = 0;
+        this.lastFailureTime = 0;
+        this.halfOpenCalls = 0;
+        this.successCount = 0;
+    }
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    async execute(fn) {
+        if (this.state === CircuitState.OPEN) {
+            if (Date.now() - this.lastFailureTime > this.options.resetTimeout) {
+                this.state = CircuitState.HALF_OPEN;
+                this.halfOpenCalls = 0;
+                this.successCount = 0;
+            }
+            else {
+                throw new Error(`Circuit breaker ${this.name} is OPEN`);
+            }
+        }
+        if (this.state === CircuitState.HALF_OPEN) {
+            if (this.halfOpenCalls >= this.options.halfOpenMaxCalls) {
+                // Too many calls in half-open, open the circuit
+                this.state = CircuitState.OPEN;
+                this.lastFailureTime = Date.now();
+                throw new Error(`Circuit breaker ${this.name} is OPEN`);
+            }
+            this.halfOpenCalls++;
+        }
+        try {
+            const result = await fn();
+            this.onSuccess();
+            return result;
+        }
+        catch (error) {
+            this.onFailure();
+            throw error;
+        }
+    }
+    onSuccess() {
+        this.failureCount = 0;
+        if (this.state === CircuitState.HALF_OPEN) {
+            this.successCount++;
+            if (this.successCount >= this.options.halfOpenMaxCalls) {
+                // Service recovered
+                this.state = CircuitState.CLOSED;
+                this.halfOpenCalls = 0;
+                this.successCount = 0;
+            }
+        }
+    }
+    onFailure() {
+        this.failureCount++;
+        this.lastFailureTime = Date.now();
+        if (this.state === CircuitState.HALF_OPEN) {
+            // Failed in half-open, open the circuit
+            this.state = CircuitState.OPEN;
+            this.halfOpenCalls = 0;
+            this.successCount = 0;
+        }
+        else if (this.failureCount >= this.options.failureThreshold) {
+            // Too many failures, open the circuit
+            this.state = CircuitState.OPEN;
+        }
+    }
+    getState() {
+        return this.state;
+    }
+    getStats() {
+        return {
+            name: this.name,
+            state: this.state,
+            failureCount: this.failureCount,
+            lastFailureTime: this.lastFailureTime,
+        };
+    }
+    reset() {
+        this.state = CircuitState.CLOSED;
+        this.failureCount = 0;
+        this.lastFailureTime = 0;
+        this.halfOpenCalls = 0;
+        this.successCount = 0;
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;
+// Global circuit breakers
+const circuitBreakers = new Map();
+/**
+ * Get or create a circuit breaker
+ */
+function getCircuitBreaker(name, options) {
+    if (!circuitBreakers.has(name)) {
+        circuitBreakers.set(name, new CircuitBreaker(name, options));
+    }
+    return circuitBreakers.get(name);
+}

package/dist/utils/concurrent-map.d.ts

@@ -0,0 +1,4 @@
+export declare function concurrentMap<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, concurrency: number): Promise<{
+    results: R[];
+    errors: Error[];
+}>;

package/dist/utils/concurrent-map.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concurrentMap = concurrentMap;
+async function concurrentMap(items, fn, concurrency) {
+    const results = new Array(items.length);
+    const errors = [];
+    let nextIndex = 0;
+    const worker = async () => {
+        while (nextIndex < items.length) {
+            const i = nextIndex++;
+            try {
+                results[i] = await fn(items[i], i);
+            }
+            catch (err) {
+                errors.push(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return { results, errors };
+}

package/dist/utils/detect-format.d.ts

@@ -0,0 +1,5 @@
+import type { DetectedFormat } from '../runtime/types';
+export declare function extractCurrency(raw: string): DetectedFormat | null;
+export declare function extractDate(raw: string): DetectedFormat | null;
+export declare function extractNumber(raw: string): DetectedFormat | null;
+export declare function detectFormat(text: string): DetectedFormat | null;

package/dist/utils/detect-format.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCurrency = extractCurrency;
+exports.extractDate = extractDate;
+exports.extractNumber = extractNumber;
+exports.detectFormat = detectFormat;
+// ─────────────────────────────────────────────────────────────
+// Currency Detection
+// ─────────────────────────────────────────────────────────────
+const CURRENCY_CODES = ['USD', 'EUR', 'GBP', 'JPY', 'CNY', 'INR', 'KRW', 'RUB', 'TRY', 'VND', 'UAH', 'NGN', 'PHP', 'GHS', 'ARS', 'BRL', 'MXN', 'CAD', 'AUD', 'CHF', 'SEK', 'NOK', 'DKK', 'NZD', 'SGD', 'HKD', 'TWD', 'THB', 'MYR', 'IDR'];
+const CURRENCY_PATTERNS = [
+    /^[€$£¥₹₩₽₺\u20B9\u20A8]?\s?\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2})?\s?[€$£¥₹₩₽₺A-Z]*$/,
+    /^[A-Z]{3}\s?\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2})?$/,
+    /^\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2})?\s?[€$£¥€]$/,
+];
+function extractCurrency(raw) {
+    const trimmed = raw.trim();
+    if (!CURRENCY_PATTERNS.some((p) => p.test(trimmed)))
+        return null;
+    const match = trimmed.match(/[\d,.\s]+(?:\.[0-9]{2})?/);
+    if (!match)
+        return null;
+    const numericPart = match[0].replace(/[^\d,.]/g, '').trim();
+    if (!numericPart)
+        return null;
+    const symbolMatch = trimmed.match(/[€$£¥₹₩₽₺\u20B9\u20A8]/);
+    const codeMatch = trimmed.match(/\b([A-Z]{3})\b/);
+    let detectedCurrency;
+    if (symbolMatch) {
+        const symbolToCode = {
+            '$': 'USD', '€': 'EUR', '£': 'GBP', '¥': 'JPY',
+            '₹': 'INR', '₩': 'KRW', '₽': 'RUB', '₺': 'TRY',
+            '₫': 'VND', '₴': 'UAH', '₦': 'NGN', '₱': 'PHP',
+            '₵': 'GHS', '₿': 'BTC',
+        };
+        detectedCurrency = symbolToCode[symbolMatch[0]] || symbolMatch[0];
+    }
+    else if (codeMatch && CURRENCY_CODES.includes(codeMatch[1])) {
+        detectedCurrency = codeMatch[1];
+    }
+    const rawNumber = numericPart.replace(/,/g, '');
+    const parsed = parseFloat(rawNumber);
+    if (isNaN(parsed))
+        return null;
+    return {
+        class: 'currency',
+        rawValue: numericPart,
+        originalString: trimmed,
+        confidence: 0.85,
+        detectedCurrency,
+    };
+}
+// ─────────────────────────────────────────────────────────────
+// Date Detection
+// ─────────────────────────────────────────────────────────────
+const DATE_PATTERNS = [
+    { regex: /^(0[1-9]|1[012])[-/](0[1-9]|[12]\d|3[01])[-/](\d{4})$/, options: { month: '2-digit', day: '2-digit', year: 'numeric' }, source: 'MM/DD/YYYY' },
+    { regex: /^(0[1-9]|[12]\d|3[01])[-/](0[1-9]|1[012])[-/](\d{4})$/, options: { day: '2-digit', month: '2-digit', year: 'numeric' }, source: 'DD/MM/YYYY' },
+    { regex: /^(\d{4})[-/](0[1-9]|1[012])[-/](0[1-9]|[12]\d|3[01])$/, options: { year: 'numeric', month: '2-digit', day: '2-digit' }, source: 'YYYY-MM-DD' },
+    { regex: /^(0[1-9]|[12]\d|3[01])\.(0[1-9]|1[012])\.(\d{4})$/, options: { day: '2-digit', month: '2-digit', year: 'numeric' }, source: 'DD.MM.YYYY' },
+    { regex: /^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+(0[1-9]|[12]\d|3[01]),\s+(\d{4})$/, options: { month: 'short', day: '2-digit', year: 'numeric' }, source: 'MMM DD, YYYY' },
+    { regex: /^(0[1-9]|[12]\d|3[01])\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+(\d{4})$/, options: { day: '2-digit', month: 'short', year: 'numeric' }, source: 'DD MMM YYYY' },
+];
+function extractDate(raw) {
+    const trimmed = raw.trim();
+    for (const { regex, options, source } of DATE_PATTERNS) {
+        const match = trimmed.match(regex);
+        if (match) {
+            return {
+                class: 'date',
+                rawValue: trimmed,
+                originalString: trimmed,
+                confidence: 0.9,
+                dateOptions: options,
+                dateSource: source,
+            };
+        }
+    }
+    return null;
+}
+// ─────────────────────────────────────────────────────────────
+// Number Detection
+// ─────────────────────────────────────────────────────────────
+const NUMBER_PATTERNS = [
+    /^-?\d{1,3}(?:,\d{3})+(?:\.\d+)?$/,
+    /^-?\d{1,3}(?:\.\d{3})+(?:,\d+)?$/,
+    /^-?\d+(?:\.\d+)?$/,
+];
+function extractNumber(raw) {
+    const trimmed = raw.trim();
+    if (!NUMBER_PATTERNS.some((p) => p.test(trimmed)))
+        return null;
+    const hasDotDecimal = /\.\d+$/.test(trimmed);
+    const hasCommaDecimal = /,\d+$/.test(trimmed);
+    const numberOptions = {};
+    if (hasDotDecimal || hasCommaDecimal) {
+        numberOptions.minimumFractionDigits = 0;
+        numberOptions.maximumFractionDigits = 10;
+    }
+    return {
+        class: 'number',
+        rawValue: trimmed,
+        originalString: trimmed,
+        confidence: 0.75,
+        numberOptions: Object.keys(numberOptions).length > 0 ? numberOptions : undefined,
+    };
+}
+// ─────────────────────────────────────────────────────────────
+// Dispatch
+// ─────────────────────────────────────────────────────────────
+function detectFormat(text) {
+    if (!text || text.length < 2)
+        return null;
+    const trimmed = text.trim();
+    const dateResult = extractDate(trimmed);
+    if (dateResult)
+        return dateResult;
+    const currencyResult = extractCurrency(trimmed);
+    if (currencyResult)
+        return currencyResult;
+    const numberResult = extractNumber(trimmed);
+    if (numberResult)
+        return numberResult;
+    return null;
+}

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

@@ -0,0 +1,29 @@
+import type { WorkspaceInfo } from '../runtime/types';
+/**
+ * How a run treats ICU, resolved once from the project and the translator
+ * and shared by extraction, translation and the sync detector, so they agree.
+ */
+export interface ResolvedIcuOptions {
+    /** Group JSX sentences into one message (needs ICU placeholders at runtime for react-i18next). */
+    sentences: boolean;
+    /** Generate ICU plurals in source sentences ("{count, plural, …}"): ICU runtime + LLM translator. */
+    plurals: boolean;
+    /**
+     * The project's runtime formats ICU messages: next-intl, or react-i18next
+     * 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. 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).
+ *            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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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).
+ *            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;
+    let sentences = true;
+    if (strategy === 'next-intl') {
+        icuRuntime = true;
+    }
+    else if (strategy === 'react-i18next') {
+        icuRuntime = (await (0, i18next_icu_1.detectI18nextIcu)(workspace)).available;
+        sentences = icuRuntime;
+    }
+    return { sentences, plurals: icuRuntime && llm, icuRuntime, targetPlurals: icuRuntime };
+}

package/dist/utils/file-utils.d.ts

@@ -0,0 +1,33 @@
+export declare function clearFindFilesCache(): void;
+export declare function readFile(filePath: string): Promise<string>;
+export declare function writeFile(filePath: string, content: string, allowedBaseDir?: string): Promise<void>;
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function isDirectory(filePath: string): Promise<boolean>;
+export declare function findFiles(dir: string, extensions: string[], excludePatterns?: string[]): Promise<string[]>;
+export declare function getRelativePath(workspacePath: string, filePath: string): string;
+export declare function readJsonFile<T = any>(filePath: string): Promise<T | null>;
+export declare function writeJsonFile(filePath: string, data: any, sortKeys?: boolean): Promise<void>;
+export declare function localeExtension(format: string): string;
+/**
+ * Compute the locale directory and file path for a given target locale.
+ * Django uses `locale/<lang>/LC_MESSAGES/django.po`,
+ * other frameworks use `<publicDir>/locales/<lang>.json`.
+ */
+export declare function localeFilePath(workspacePath: string, publicDir: string, localeFormat: string, targetLocale: string): {
+    dir: string;
+    file: string;
+    relativeFile: string;
+};
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function copyFile(src: string, dest: string): Promise<void>;
+export declare function deleteFile(filePath: string): Promise<void>;
+export declare function readDir(dirPath: string): Promise<string[]>;
+/**
+ * Process items with bounded concurrency.
+ * Unlike Promise.all, this limits the number of concurrent operations.
+ * Errors are collected and returned alongside results.
+ */
+export declare function concurrentMap<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, concurrency: number): Promise<{
+    results: R[];
+    errors: Error[];
+}>;

package/dist/utils/file-utils.js

@@ -0,0 +1,267 @@
+"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.clearFindFilesCache = clearFindFilesCache;
+exports.readFile = readFile;
+exports.writeFile = writeFile;
+exports.pathExists = pathExists;
+exports.isDirectory = isDirectory;
+exports.findFiles = findFiles;
+exports.getRelativePath = getRelativePath;
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+exports.localeExtension = localeExtension;
+exports.localeFilePath = localeFilePath;
+exports.ensureDir = ensureDir;
+exports.copyFile = copyFile;
+exports.deleteFile = deleteFile;
+exports.readDir = readDir;
+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.
+ *
+ * This is a direct carry-over of the v1 utilities to preserve behavior.
+ */
+const findFilesCache = new Map();
+function clearFindFilesCache() {
+    findFilesCache.clear();
+}
+function findFilesCacheKey(dir, extensions, excludePatterns) {
+    return `${dir}::${extensions.sort().join(',')}::${excludePatterns.sort().join(',')}`;
+}
+async function readFile(filePath) {
+    return fs.promises.readFile(filePath, 'utf-8');
+}
+async function writeFile(filePath, content, allowedBaseDir) {
+    const resolved = path.resolve(filePath);
+    if (allowedBaseDir && !resolved.startsWith(path.resolve(allowedBaseDir))) {
+        throw new Error(`Path traversal detected: ${filePath} is outside ${allowedBaseDir}`);
+    }
+    const dir = path.dirname(resolved);
+    await fs.promises.mkdir(dir, { recursive: true });
+    // Atomic write: write to tmp, then rename to prevent partial/corrupt files on crash
+    const tmpPath = resolved + '.tmp';
+    await fs.promises.writeFile(tmpPath, content, 'utf-8'); // codeql[js/http-to-file-access] — engine writes translation output to workspace; callers authenticate + authorize
+    await fs.promises.rename(tmpPath, resolved);
+}
+async function pathExists(filePath) {
+    try {
+        await fs.promises.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(filePath) {
+    try {
+        const stats = await fs.promises.stat(filePath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function findFiles(dir, extensions, excludePatterns = []) {
+    const key = findFilesCacheKey(dir, extensions, excludePatterns);
+    const cached = findFilesCache.get(key);
+    if (cached)
+        return cached;
+    const promise = findFilesUncached(dir, extensions, excludePatterns);
+    findFilesCache.set(key, promise);
+    return promise;
+}
+/** Exclusion names that usually mean generated output (but not inside SOURCE_TREE_DIRS). */
+const OUTPUT_DIR_NAMES = new Set(['build', 'dist', 'coverage', 'lib', 'libs', 'vendor']);
+/** Directories whose subdirectories are routes or components, never build output. */
+const SOURCE_TREE_DIRS = new Set(['app', 'pages', 'components']);
+function isInsideSourceTree(walkRoot, relativePath) {
+    const ancestors = [path.basename(walkRoot), ...relativePath.split(path.sep).slice(0, -1)];
+    return ancestors.some((segment) => SOURCE_TREE_DIRS.has(segment));
+}
+async function findFilesUncached(dir, extensions, excludePatterns = []) {
+    const results = [];
+    async function walk(currentDir) {
+        const entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = path.relative(dir, fullPath);
+            const shouldExclude = excludePatterns.some((pattern) => {
+                if (pattern.includes('*')) {
+                    const escaped = (0, string_utils_1.escapeRegex)(pattern).replace(/\*/g, '.*');
+                    const regex = new RegExp(escaped);
+                    return regex.test(entry.name) || regex.test(relativePath);
+                }
+                // Whole path segments only: a substring match excluded files like
+                // `components/Calibrate.tsx` ("lib") or `app/distance/page.tsx` ("dist").
+                if (pattern.includes('/')) {
+                    const rel = relativePath.split(path.sep).join('/');
+                    return rel === pattern || rel.startsWith(`${pattern}/`);
+                }
+                if (entry.name !== pattern)
+                    return false;
+                // Build-output names are real source inside routing/component trees
+                // (a Next.js route `app/build/page.tsx`); output never lives there.
+                if (OUTPUT_DIR_NAMES.has(pattern) && isInsideSourceTree(dir, relativePath))
+                    return false;
+                return true;
+            });
+            if (shouldExclude)
+                continue;
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (extensions.includes(ext)) {
+                    results.push(fullPath);
+                }
+            }
+        }
+    }
+    await walk(dir);
+    return results;
+}
+function getRelativePath(workspacePath, filePath) {
+    return path.relative(workspacePath, filePath).replace(/\\/g, '/');
+}
+async function readJsonFile(filePath) {
+    try {
+        const content = await readFile(filePath);
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeJsonFile(filePath, data, sortKeys = true) {
+    let content;
+    if (sortKeys && typeof data === 'object' && data !== null) {
+        content = JSON.stringify(sortObjectKeys(data), null, 2);
+    }
+    else {
+        content = JSON.stringify(data, null, 2);
+    }
+    await writeFile(filePath, content + '\n');
+}
+function sortObjectKeys(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(sortObjectKeys);
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        const sorted = {};
+        const keys = Object.keys(obj).sort();
+        for (const key of keys) {
+            sorted[key] = sortObjectKeys(obj[key]);
+        }
+        return sorted;
+    }
+    return obj;
+}
+function localeExtension(format) {
+    return format === 'po' ? '.po' : '.json';
+}
+/**
+ * Compute the locale directory and file path for a given target locale.
+ * Django uses `locale/<lang>/LC_MESSAGES/django.po`,
+ * other frameworks use `<publicDir>/locales/<lang>.json`.
+ */
+function localeFilePath(workspacePath, publicDir, localeFormat, targetLocale) {
+    if (localeFormat === 'po') {
+        // 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(localeDir, name, 'LC_MESSAGES', 'django.po');
+        return { dir, file, relativeFile };
+    }
+    const ext = localeExtension(localeFormat);
+    const dir = path.join(workspacePath, publicDir, 'locales');
+    const file = path.join(dir, `${targetLocale}${ext}`);
+    const relativeFile = path.join(publicDir, 'locales', `${targetLocale}${ext}`);
+    return { dir, file, relativeFile };
+}
+async function ensureDir(dirPath) {
+    await fs.promises.mkdir(dirPath, { recursive: true });
+}
+async function copyFile(src, dest) {
+    await ensureDir(path.dirname(dest));
+    await fs.promises.copyFile(src, dest);
+}
+async function deleteFile(filePath) {
+    try {
+        await fs.promises.unlink(filePath);
+    }
+    catch {
+        // ignore
+    }
+}
+async function readDir(dirPath) {
+    try {
+        return await fs.promises.readdir(dirPath);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Process items with bounded concurrency.
+ * Unlike Promise.all, this limits the number of concurrent operations.
+ * Errors are collected and returned alongside results.
+ */
+async function concurrentMap(items, fn, concurrency) {
+    const results = new Array(items.length);
+    const errors = [];
+    let nextIndex = 0;
+    const worker = async () => {
+        while (nextIndex < items.length) {
+            const i = nextIndex++;
+            try {
+                results[i] = await fn(items[i], i);
+            }
+            catch (err) {
+                errors.push(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return { results, errors };
+}

package/dist/utils/glossary-match.d.ts

@@ -0,0 +1,9 @@
+/** Shared by the translate phase and locale QA so both judge glossary use the same way. */
+/**
+ * Whether the required glossary translation appears in the output, allowing
+ * for inflection: each of its words must match a word in the output on a
+ * shared stem (Polish "obszar roboczy" → "obszarem roboczym", German
+ * "Arbeitsbereich" → "Arbeitsbereichs"). Scripts without spaces fall back to a
+ * substring check.
+ */
+export declare function containsGlossaryTranslation(translated: string, required: string): boolean;