@babelize/engine 0.0.0-stage → 0.1.0

package/dist/analysis/analyze.js

@@ -0,0 +1,323 @@
+"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.frameworkSupport = frameworkSupport;
+exports.analyzeProject = analyzeProject;
+exports.analyzeWorkspace = analyzeWorkspace;
+/**
+ * Localization readiness of a local project, from the same pipeline phases
+ * `babelize translate` runs — validate, extract, keygen, inject and finalize,
+ * all in dry-run mode on a temp copy — but with no translation, no network
+ * and no writes to the project.
+ */
+const path = __importStar(require("path"));
+const types_1 = require("@babelize/types");
+const workspace_1 = require("../modules/workspace");
+const extract_1 = require("../modules/extractor/extract");
+const keygen_1 = require("../modules/keygen");
+const locale_builder_1 = require("../modules/locale-builder");
+const injection_1 = require("../modules/injection");
+const finalization_1 = require("../modules/finalization");
+const finalize_1 = require("../modules/finalization/finalize");
+const file_utils_1 = require("../utils/file-utils");
+const not_injected_1 = require("../utils/not-injected");
+const key_usage_1 = require("../utils/key-usage");
+const extraction_options_1 = require("../utils/extraction-options");
+const check_project_1 = require("../qa/check-project");
+const workspace_copy_1 = require("../local/workspace-copy");
+const translate_core_1 = require("../local/translate-core");
+const static_runtime_1 = require("../modules/finalization/static-runtime");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs_1 = require("fs");
+/** How well `babelize translate` handles a detected framework. */
+function frameworkSupport(framework) {
+    if (translate_core_1.SUPPORTED_LOCAL_FRAMEWORKS.includes(framework))
+        return 'supported';
+    if (translate_core_1.BETA_LOCAL_FRAMEWORKS.includes(framework))
+        return 'beta';
+    return 'unsupported';
+}
+const ADVISORY_WARNINGS = new Set(['hardcoded-currency', 'hardcoded-date', 'hardcoded-plural', 'complex-expression', 'dynamic-string', 'ambiguous-format']);
+function lineOf(extractionId) {
+    const n = Number(extractionId.split(':')[1]);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+function toPosix(p) {
+    return p.split(path.sep).join('/');
+}
+/** Analyze `projectDir` on a temp copy; the project itself is only read. */
+async function analyzeProject(projectDir, options = {}) {
+    const dir = path.resolve(projectDir);
+    // Same copy translate makes (gitignored files skipped in a repo), so the
+    // report matches what a run would see.
+    const temp = await (0, workspace_copy_1.createTempCopy)(dir, { files: (await (0, workspace_copy_1.listGitFiles)(dir)) ?? undefined, tmpRoot: options.tmpRoot });
+    try {
+        return await analyzeWorkspace(temp.dir, options);
+    }
+    finally {
+        await temp.cleanup();
+    }
+}
+/**
+ * Analyze a workspace in place. Pipeline phases run in dry-run mode, but
+ * framework detection creates `.babelize/`: call it on a disposable copy
+ * (see {@link analyzeProject}).
+ */
+async function analyzeWorkspace(workspacePath, options = {}) {
+    const startedAt = Date.now();
+    const config = await (0, check_project_1.readProjectLocaleConfig)(workspacePath);
+    const sourceLocale = options.sourceLocale ?? config.sourceLocale ?? 'en';
+    const targetLocales = (options.targetLocales ?? config.targetLocales ?? []).filter((l) => l !== sourceLocale);
+    const empty = (framework, error) => ({
+        framework,
+        support: 'unsupported',
+        error,
+        sourceLocale,
+        setup: { library: 'none', missingDependencies: [], wiredUp: false, pendingChanges: [], notes: [] },
+        files: { scanned: 0, withStrings: 0, skipped: [] },
+        strings: [],
+        groupedSentences: [],
+        fragmentedSentences: [],
+        notInjectable: [],
+        warnings: [],
+        locales: [],
+        unusedKeys: [],
+        dynamicKeyFiles: [],
+        nextSteps: [error],
+        durationMs: Date.now() - startedAt,
+    });
+    (0, file_utils_1.clearFindFilesCache)();
+    let workspace;
+    try {
+        ({ workspace } = await (0, workspace_1.validateWorkspace)({
+            workspacePath,
+            inputType: 'zip',
+            sourceLocale,
+            targetLocales,
+            confidenceThreshold: 80,
+            dryRun: true,
+        }));
+    }
+    catch (err) {
+        return empty('unknown', err.message);
+    }
+    const framework = workspace.framework;
+    const support = frameworkSupport(framework);
+    if (support === 'unsupported') {
+        return empty(framework, `Detected ${framework}, which local translation does not support. Supported: React and Next.js (Vue and static HTML in beta).`);
+    }
+    const phases = (types_1.FRAMEWORK_CONFIGS[framework] ?? types_1.FRAMEWORK_CONFIGS.unknown).phases;
+    // Same ICU decision as a local translate run (whose translator is an LLM).
+    const icuOptions = await (0, extraction_options_1.resolveIcuOptions)(workspace, true);
+    const { extraction } = await (0, extract_1.extractStrings)(workspace, undefined, icuOptions);
+    const existing = workspace.localeFormat === 'json' ? ((await (0, locale_builder_1.readLocaleFile)(workspace, sourceLocale)) ?? {}) : {};
+    const { keyGeneration } = (0, keygen_1.generateKeys)(extraction.strings, existing);
+    let injection = { modifiedFiles: [], skippedFiles: [], totalInjections: 0 };
+    if (phases.includes('inject')) {
+        const positions = new Map();
+        for (const str of extraction.strings)
+            if (str.offsets)
+                positions.set(str.id, new Set(str.offsets));
+        injection = await (0, injection_1.injectTranslations)(workspace, (0, keygen_1.createKeyMapping)(keyGeneration.keys), 80, true, positions);
+    }
+    const lineByKey = new Map(keyGeneration.keys.map((k) => [`${k.extractionId.split(':')[0]}\u0000${k.key}`, lineOf(k.extractionId)]));
+    const notInjectable = phases.includes('inject')
+        ? [...(0, not_injected_1.findNotInjected)(keyGeneration, injection), ...(extraction.notInjected ?? [])].map((n) => ({
+            file: n.file,
+            line: lineByKey.get(`${n.file}\u0000${n.key}`),
+            text: n.text,
+            reason: n.reason,
+        }))
+        : [];
+    // What translate's finalize phase would still change to wire i18n up.
+    const runtime = (0, finalize_1.i18nRuntimeFor)(framework, workspace.packageJson);
+    const pendingChanges = [];
+    const notes = [];
+    if (framework === 'static') {
+        // finalize always rewrites its own i18n.js, so it can't tell "set up"
+        // from "not set up": look at the real state instead.
+        const wiring = await staticWiring(workspacePath);
+        if (wiring.runtime === 'missing')
+            pendingChanges.push('create the i18n.js runtime');
+        if (wiring.runtime === 'user')
+            notes.push('i18n.js exists but was not generated by Babelize; translate leaves it untouched.');
+        if (wiring.pagesWithoutScript.length) {
+            pendingChanges.push(`add <script src="i18n.js"> to ${wiring.pagesWithoutScript.length} HTML page(s)`);
+        }
+    }
+    else if (phases.includes('finalize')) {
+        try {
+            const { finalization } = await (0, finalization_1.finalizeProject)(workspace, true, { targetLocales, sourceLocale, installDependencies: false });
+            if (finalization.configFileCreated)
+                pendingChanges.push(`create or update the ${runtime.library} config`);
+            if (finalization.entryPointModified)
+                pendingChanges.push('wire the i18n provider into the app entry point / root layout');
+            notes.push(...(finalization.warnings ?? []).filter((w) => !/missing dependencies/i.test(w) && !/^Created i18n\.js/.test(w)));
+        }
+        catch (err) {
+            notes.push(`Could not check the i18n wiring: ${err.message}`);
+        }
+    }
+    if (!icuOptions.sentences) {
+        notes.push('react-i18next without i18next-icu: sentences with variables or inline tags stay split into fragments. Add i18next-icu to translate them as whole messages.');
+    }
+    if (runtime.missing.length)
+        pendingChanges.unshift(`add ${runtime.missing.join(', ')} to package.json`);
+    const asString = (s) => ({ file: s.file, line: s.line, text: s.text, context: s.context });
+    const strings = extraction.strings.map(asString);
+    const groupedSentences = extraction.strings.filter((s) => s.icuMessage).map(asString);
+    const fragments = new Map();
+    for (const s of extraction.strings) {
+        if (!s.siblingGroupId || s.icuMessage)
+            continue;
+        const id = `${s.file}\u0000${s.siblingGroupId}`;
+        fragments.set(id, [...(fragments.get(id) ?? []), s]);
+    }
+    const fragmentedSentences = [...fragments.values()]
+        .filter((group) => group.length >= 2)
+        .map((group) => ({
+        file: group[0].file,
+        line: Math.min(...group.map((g) => g.line)),
+        sentence: (group[0].parentContext ?? group.map((g) => g.text).join(' … ')).replace(/\{#\d+\}/g, '<…>'),
+        pieces: group.length,
+    }));
+    const sourceKeys = {};
+    for (const [k, v] of Object.entries((0, keygen_1.flattenLocaleData)(existing))) {
+        if (k !== '_meta' && !k.startsWith('_meta.'))
+            sourceKeys[k] = v;
+    }
+    const usage = await (0, key_usage_1.reportKeyUsage)(workspace, sourceKeys, new Set(keyGeneration.keys.map((k) => k.key)));
+    const check = await (0, check_project_1.checkProjectLocales)(workspacePath, { sourceLocale, locales: targetLocales.length ? targetLocales : undefined });
+    const locales = check.sets.map((set) => ({
+        dir: set.dir,
+        sourceKeys: set.sourceKeys,
+        locales: set.locales.map((l) => ({
+            locale: l.locale,
+            total: l.total,
+            translated: l.translated,
+            missing: l.counts.missing_key ?? 0,
+            errors: l.errors,
+            warnings: l.warnings,
+        })),
+        missingLocales: set.missingLocales,
+    }));
+    const skipped = [...extraction.skippedFiles, ...injection.skippedFiles].map((f) => ({
+        file: toPosix(f.file),
+        reason: f.details ? `${f.reason}: ${f.details.split('\n')[0]}` : f.reason,
+    }));
+    const warnings = (extraction.warnings ?? [])
+        .filter((w) => ADVISORY_WARNINGS.has(w.type))
+        .map((w) => ({ type: w.type, file: w.file, line: w.line, message: w.message }));
+    const analysis = {
+        framework,
+        support,
+        sourceLocale,
+        setup: {
+            library: runtime.library,
+            missingDependencies: runtime.missing,
+            wiredUp: pendingChanges.length === 0,
+            pendingChanges,
+            notes,
+        },
+        files: {
+            scanned: extraction.filesAnalyzed.length,
+            withStrings: new Set(extraction.strings.map((s) => s.file)).size,
+            skipped,
+        },
+        strings,
+        groupedSentences,
+        fragmentedSentences,
+        notInjectable,
+        warnings,
+        locales,
+        unusedKeys: usage.unused,
+        dynamicKeyFiles: usage.dynamicFiles,
+        nextSteps: [],
+        durationMs: 0,
+    };
+    analysis.nextSteps = recommendNextSteps(analysis, targetLocales);
+    analysis.durationMs = Date.now() - startedAt;
+    return analysis;
+}
+/** Static sites: is the Babelize i18n.js runtime there, and does every page load it? */
+async function staticWiring(root) {
+    const runtimeSrc = await fs_1.promises.readFile(path.join(root, 'i18n.js'), 'utf8').catch(() => '');
+    const runtime = (0, static_runtime_1.checkRuntimeNeedsRegeneration)(runtimeSrc);
+    const pages = await (0, fast_glob_1.default)(['**/*.html', '**/*.htm'], {
+        cwd: root,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**', '**/.babelize/**'],
+        onlyFiles: true,
+        deep: 8,
+    });
+    const pagesWithoutScript = [];
+    for (const page of pages.sort()) {
+        const html = await fs_1.promises.readFile(path.join(root, page), 'utf8').catch(() => '');
+        if (!/<script[^>]+src=["'][^"']*i18n\.js["']/i.test(html))
+            pagesWithoutScript.push(page);
+    }
+    return { runtime, pagesWithoutScript };
+}
+function recommendNextSteps(a, targetLocales) {
+    const steps = [];
+    const to = targetLocales.length ? targetLocales.join(', ') : 'your target locales (e.g. de, ja)';
+    const localeGaps = a.locales.flatMap((s) => s.locales).filter((l) => l.missing > 0);
+    const requestedMissing = a.locales.flatMap((s) => s.missingLocales);
+    if (a.support === 'beta')
+        steps.push(`${a.framework} support is in beta: review the changes carefully.`);
+    if (a.strings.length > 0) {
+        steps.push(`Translate: extract ${a.strings.length} hardcoded string(s), wire them to ${a.setup.library} and translate into ${to}.`);
+    }
+    else if (localeGaps.length > 0 || requestedMissing.length > 0) {
+        steps.push(`Translate: fill ${localeGaps.reduce((n, l) => n + l.missing, 0)} missing translation(s)${requestedMissing.length ? ` and add ${[...new Set(requestedMissing)].join(', ')}` : ''}.`);
+    }
+    else if (a.locales.length === 0) {
+        steps.push('No hardcoded strings or locale files found: nothing to localize yet.');
+    }
+    if (a.notInjectable.length > 0) {
+        steps.push(`${a.notInjectable.length} string(s) can't be wired automatically: move them into a component or call t() by hand after translating.`);
+    }
+    if (a.setup.missingDependencies.length > 0) {
+        steps.push(`After translating, install ${a.setup.missingDependencies.join(', ')} with your package manager.`);
+    }
+    if (a.locales.some((s) => s.locales.some((l) => l.errors > 0))) {
+        steps.push('Existing locale files have errors (placeholders, ICU, plural forms): run the check.');
+    }
+    if (steps.length === 0)
+        steps.push('Looks localized. Re-run the check after editing strings or locale files.');
+    return steps;
+}

package/dist/config/env.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Environment the engine reads directly. Read lazily so a host that loads
+ * dotenv after importing the engine still sees its values, and so importing
+ * the engine never requires any variable to be set.
+ */
+export declare const config: {
+    readonly GEMINI_API_KEY: string | undefined;
+    readonly GROQ_API_KEY: string | undefined;
+};

package/dist/config/env.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+/**
+ * Environment the engine reads directly. Read lazily so a host that loads
+ * dotenv after importing the engine still sees its values, and so importing
+ * the engine never requires any variable to be set.
+ */
+exports.config = {
+    get GEMINI_API_KEY() {
+        return process.env.GEMINI_API_KEY;
+    },
+    get GROQ_API_KEY() {
+        return process.env.GROQ_API_KEY;
+    },
+};

package/dist/config.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import type { BabelizeConfig } from './types';
+declare const configSchema: z.ZodObject<{
+    workspacePath: z.ZodString;
+    sourceLocale: z.ZodDefault<z.ZodString>;
+    targetLocales: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    framework: z.ZodOptional<z.ZodEnum<["react", "nextjs", "vue", "static", "unknown", "django"]>>;
+    dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    projectId: z.ZodOptional<z.ZodString>;
+    sourceDir: z.ZodOptional<z.ZodString>;
+    localesDir: z.ZodOptional<z.ZodString>;
+    glossary: z.ZodOptional<z.ZodObject<{
+        neverTranslate: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        alwaysTranslateAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            term: z.ZodString;
+            translations: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            term: string;
+            translations: Record<string, string>;
+        }, {
+            term: string;
+            translations: Record<string, string>;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        neverTranslate: string[];
+        alwaysTranslateAs: {
+            term: string;
+            translations: Record<string, string>;
+        }[];
+    }, {
+        neverTranslate?: string[] | undefined;
+        alwaysTranslateAs?: {
+            term: string;
+            translations: Record<string, string>;
+        }[] | undefined;
+    }>>;
+    lockfilePath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workspacePath: string;
+    sourceLocale: string;
+    targetLocales: string[];
+    dryRun: boolean;
+    framework?: "react" | "nextjs" | "vue" | "static" | "unknown" | "django" | undefined;
+    projectId?: string | undefined;
+    sourceDir?: string | undefined;
+    localesDir?: string | undefined;
+    glossary?: {
+        neverTranslate: string[];
+        alwaysTranslateAs: {
+            term: string;
+            translations: Record<string, string>;
+        }[];
+    } | undefined;
+    lockfilePath?: string | undefined;
+}, {
+    workspacePath: string;
+    sourceLocale?: string | undefined;
+    targetLocales?: string[] | undefined;
+    framework?: "react" | "nextjs" | "vue" | "static" | "unknown" | "django" | undefined;
+    dryRun?: boolean | undefined;
+    projectId?: string | undefined;
+    sourceDir?: string | undefined;
+    localesDir?: string | undefined;
+    glossary?: {
+        neverTranslate?: string[] | undefined;
+        alwaysTranslateAs?: {
+            term: string;
+            translations: Record<string, string>;
+        }[] | undefined;
+    } | undefined;
+    lockfilePath?: string | undefined;
+}>;
+export declare function loadBabelizeConfig(input: unknown): BabelizeConfig;
+export { configSchema as babelizeConfigSchema };

package/dist/config.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.babelizeConfigSchema = void 0;
+exports.loadBabelizeConfig = loadBabelizeConfig;
+const zod_1 = require("zod");
+const types_1 = require("@babelize/types");
+const isoCode = zod_1.z
+    .string()
+    .trim()
+    .toLowerCase()
+    .regex(/^[a-z]{2}$/, 'Expected ISO 639-1 (e.g. "en")');
+const configSchema = zod_1.z.object({
+    workspacePath: zod_1.z.string().min(1),
+    sourceLocale: isoCode.default('en'),
+    targetLocales: zod_1.z.array(isoCode).default([]),
+    framework: zod_1.z.enum(types_1.FRAMEWORKS).optional(),
+    dryRun: zod_1.z.boolean().optional().default(false),
+    projectId: zod_1.z.string().optional(),
+    sourceDir: zod_1.z.string().optional(),
+    localesDir: zod_1.z.string().optional(),
+    glossary: zod_1.z
+        .object({
+        neverTranslate: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+        alwaysTranslateAs: zod_1.z.array(zod_1.z.object({
+            term: zod_1.z.string().min(1),
+            translations: zod_1.z.record(zod_1.z.string(), zod_1.z.string()),
+        })).default([]),
+    })
+        .optional(),
+    lockfilePath: zod_1.z.string().optional(),
+});
+exports.babelizeConfigSchema = configSchema;
+function loadBabelizeConfig(input) {
+    const parsed = configSchema.parse(input);
+    if (parsed.targetLocales.includes(parsed.sourceLocale)) {
+        console.warn(`[babelize] sourceLocale "${parsed.sourceLocale}" was also listed in targetLocales. ` +
+            `It has been removed from the target list — the source locale is always generated ` +
+            `separately by handleBaseLocale.`);
+    }
+    // Normalize/defensive defaults beyond Zod
+    const targetLocales = Array.from(new Set(parsed.targetLocales)).filter((l) => l !== parsed.sourceLocale);
+    return {
+        ...parsed,
+        targetLocales,
+        glossary: parsed.glossary ?? { neverTranslate: [], alwaysTranslateAs: [] },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Babelize Engine v2 — public API.
+ *
+ * This folder is introduced alongside the existing v1 engine (phases/*) using a
+ * strangler-fig approach. Nothing outside v2 should import internal modules
+ * directly — only this file re-exports the public surface.
+ */
+export { BabelizeEngine } from './BabelizeEngine';
+export type { BabelizeConfig, BabelizeEngineDependencies, BabelRunResult, ExtractedString, TranslationResult, TranslationUnit, } from './types';
+export { loadBabelizeConfig } from './config';
+export { runEngineV2, validateEngineConfigV2 } from './runtime';
+export type { EngineConfigV2, EngineResultV2 } from './runtime';
+export type { KeyUsageReport, ProcessingStats } from './runtime/types';
+export { scanKeyReferences } from './utils/key-usage';
+export { validateWorkspace } from './modules/workspace';
+export * from './providers';
+export { runWithEngineLogger, setEngineLogger } from './utils/logger';
+export type { EngineLogger, LogContext } from './utils/logger';
+export * from './modules/lockfile';
+export * from './modules/translator/language-codes';
+export type { MemoryEntry, FuzzyMatch, MemoryLookupResult } from './modules/translator/memory/types';
+export { matchFromMemory } from './modules/translator/memory/memory-matcher';
+export { detectSyncIssues, formatSyncNotificationMessage } from './modules/sync-detector';
+export type { SyncDetectionResult, SyncDetectedString, SyncMissingLocaleKey } from './modules/sync-detector';
+export type { TranslationEntry, WorkspaceInfo } from './runtime/types';
+export { addBabelToHistory, detectProjectInfo, getBabelizeSummary, getProjectInfo, saveCachedStrings, saveProjectConfig, } from './utils/metadata';
+export type { BabelHistoryEntry, ExtractedStringEntry, ProjectInfo } from './utils/metadata';
+export { parseCode } from './utils/ast-helpers';
+export { extractPlaceholders, hasICUSyntax, hashString, protectPlaceholders, restorePlaceholders, } from './utils/string-utils';
+export { sanitizeTranslation, validateRawTokens } from './utils/translation-sanitizer';
+export { checkTokens, hasNothingToTranslate, protectText, restoreText, sameProtectedSpans } from './utils/placeholder-protection';
+export type { ProtectedText, TokenCheck } from './utils/placeholder-protection';
+export { compareIcuMessages, isIcuMessage, parseIcu, requiredPluralCategories } from './utils/icu-message';
+export type { IcuIssue, IcuNode } from './utils/icu-message';
+export { callTranslator, checkTranslatorHealth, warmupTranslator } from './utils/translator-caller';
+export { translatorLoadBalancer } from './utils/translator-load-balancer';
+export type { TranslatorEndpoint } from './utils/translator-load-balancer';
+export { validateTranslationQuality, validateBatchQuality } from './utils/translation-quality';
+export type { QualityIssue, QualityResult } from './utils/translation-quality';
+export { CircuitBreaker, CircuitState, getCircuitBreaker } from './utils/circuit-breaker';
+export type { CircuitBreakerOptions } from './utils/circuit-breaker';
+export { localeExtension } from './utils/file-utils';
+export { analyzeProject, analyzeWorkspace, frameworkSupport, } from './analysis/analyze';
+export type { AnalyzeOptions, AnalyzedString, FrameworkSupport, ProjectAnalysis } from './analysis/analyze';
+export { checkLocalePair, flattenLocaleMessages, tallyLocaleIssues } from './qa/locale-qa';
+export type { LocaleGlossary, LocaleIssue, LocaleIssueCode, LocaleIssueSeverity, LocalePairOptions, LocalePairReport, } from './qa/locale-qa';
+export { DEFAULT_LOCALE_IGNORE_DIRS, findLocaleFileSets, groupLocaleFiles, isIgnoredLocalePath, isLocaleCode, loadLocale } from './qa/locale-files';
+export type { FindLocaleOptions, LoadedLocale, LocaleFileSet, ProjectFileReader } from './qa/locale-files';
+export { reviewLocaleChanges, ReviewError } from './qa/review';
+export type { LocaleChangeReview, LocaleSetChangeReview, ReviewOptions } from './qa/review';
+export { checkProjectLocales, localeIssueFile, readProjectLocaleConfig } from './qa/check-project';
+export type { CheckProjectOptions, LocaleSetReport, ProjectLocaleCheck, ProjectLocaleConfig } from './qa/check-project';
+export { hashText, translationCacheKey, TRANSLATION_CACHE_TTL_SECONDS } from './utils/cache-keys';
+export * from './local';