@babelize/engine 0.0.0-stage → 0.1.2

package/dist/local/git.js

@@ -0,0 +1,136 @@
+"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.GitError = void 0;
+exports.isBabelizeReportFile = isBabelizeReportFile;
+exports.isGitIgnored = isGitIgnored;
+exports.assertGitRepo = assertGitRepo;
+exports.getUncommittedChanges = getUncommittedChanges;
+exports.assertCleanTree = assertCleanTree;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/**
+ * True when `file` is a Babelize translate report: JSON whose first field is
+ * `"$schema": "https://babelize.co/schemas/translate-report.v…"`, wherever it
+ * was written (`--report <path>`). Identified by content, not by name.
+ */
+async function isBabelizeReportFile(file) {
+    if (!file.endsWith('.json'))
+        return false;
+    let handle;
+    try {
+        handle = await (0, promises_1.open)(file, 'r');
+        const buf = Buffer.alloc(256);
+        const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+        return REPORT_HEAD.test(buf.subarray(0, bytesRead).toString('utf8'));
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+const REPORT_HEAD = /^\s*\{\s*"\$schema"\s*:\s*"https:\/\/babelize\.co\/schemas\/translate-report\.v\d+\.json"/;
+/** Whether `rel` (relative to `dir`) is git-ignored. */
+async function isGitIgnored(dir, rel) {
+    try {
+        await git(dir, ['check-ignore', '-q', '--', rel]);
+        return true; // exit 0 = ignored
+    }
+    catch {
+        return false;
+    }
+}
+class GitError extends Error {
+    constructor(message, code, dirtyFiles = []) {
+        super(message);
+        this.code = code;
+        this.dirtyFiles = dirtyFiles;
+        this.name = 'GitError';
+    }
+}
+exports.GitError = GitError;
+async function git(cwd, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd, maxBuffer: 64 * 1024 * 1024 });
+    return stdout;
+}
+/** Throws GitError('not_a_repo' | 'git_missing') unless `dir` is inside a git work tree. */
+async function assertGitRepo(dir) {
+    try {
+        const out = await git(dir, ['rev-parse', '--is-inside-work-tree']);
+        if (out.trim() !== 'true')
+            throw new Error('not inside a work tree');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            throw new GitError('git is not installed or not on PATH.', 'git_missing');
+        }
+        throw new GitError('Not a git repository. `babelize translate` writes into your working tree so you can review the result with `git diff` — run it inside a git repo (or `git init` first).', 'not_a_repo');
+    }
+}
+/** Uncommitted changes under `dir` (tracked edits and untracked files), as porcelain lines. */
+async function getUncommittedChanges(dir) {
+    const out = await git(dir, ['status', '--porcelain', '--untracked-files=all', '--', '.']);
+    return out.split('\n').filter((line) => line.trim().length > 0);
+}
+/**
+ * Refuse to run on a dirty tree unless `force`: the result has to be reviewable
+ * as its own `git diff`, and a failed review has to be undoable with
+ * `git checkout . && git clean -fd` without losing the user's work.
+ */
+async function assertCleanTree(dir, force) {
+    // The QA report of an earlier run (default or --report path) is not the user's work.
+    const changes = await getUncommittedChanges(dir);
+    const root = changes.some((l) => l.startsWith('?? ')) ? (await git(dir, ['rev-parse', '--show-toplevel'])).trim() : dir;
+    const dirty = [];
+    for (const line of changes) {
+        // Porcelain paths are relative to the repository root; quoted ones (unusual characters) are kept as dirty.
+        const untracked = /^\?\? ([^"].*)$/.exec(line);
+        if (untracked && (await isBabelizeReportFile(path.join(root, untracked[1]))))
+            continue;
+        dirty.push(line);
+    }
+    if (dirty.length > 0 && !force) {
+        const preview = dirty.slice(0, 10).map((l) => `  ${l}`).join('\n');
+        const more = dirty.length > 10 ? `\n  … and ${dirty.length - 10} more` : '';
+        throw new GitError(`Your working tree has uncommitted changes:\n${preview}${more}\n` +
+            'Commit or stash them first so the translation shows up as its own reviewable `git diff`, or re-run with --force.', 'dirty', dirty);
+    }
+    return dirty;
+}

package/dist/local/hosted-provider.d.ts

@@ -0,0 +1,68 @@
+import type { KeyResult, TranslationBatchRequest, TranslationProvider } from '../providers/types';
+/**
+ * Babelize-hosted translation for `babelize translate`: a TranslationProvider
+ * that sends the engine's already placeholder-protected strings (never code)
+ * to POST {apiUrl}/v1/translate/batch with a Babelize API key. The engine
+ * still validates every result and runs its repair retry locally; model,
+ * quota and credits are decided by the server.
+ */
+/** Server limit on entries per request. */
+export declare const HOSTED_MAX_BATCH: 100;
+/**
+ * Per-attempt timeout. Longer than the server's total model budget (90 s),
+ * so the server finishes — or gives up uncharged — before we retry.
+ */
+export declare const HOSTED_REQUEST_TIMEOUT_MS = 150000;
+/** Response header naming the model that served a batch. */
+export declare const HOSTED_MODEL_HEADER = "x-babelize-model";
+export declare const API_KEYS_URL = "https://app.babelize.co/api-keys";
+export declare const BILLING_URL = "https://app.babelize.co/billing";
+export type HostedErrorCode = 
+/** 401/403: the key is missing, wrong or revoked. */
+'hosted_auth'
+/** 402: the account is out of AI credits. */
+ | 'hosted_credits'
+/** 429 after the bounded retries. */
+ | 'hosted_rate_limited'
+/** 503 hosted translation off, 5xx or network failure after retries. */
+ | 'hosted_unavailable'
+/** 400: the server rejected the request. */
+ | 'hosted_bad_request';
+export declare class HostedTranslationError extends Error {
+    readonly code: HostedErrorCode;
+    readonly status?: number | undefined;
+    constructor(message: string, code: HostedErrorCode, status?: number | undefined);
+    /** Errors after which no further request can succeed in this run. */
+    get fatal(): boolean;
+}
+export interface HostedProviderOptions {
+    /** Babelize API key (bblz_sk_…). Never printed. */
+    apiKey: string;
+    /** e.g. https://api.babelize.co/api */
+    apiUrl: string;
+    fetch?: typeof fetch;
+    /** Retries after a 429/5xx/network error (default 3). */
+    maxRetries?: number;
+    /** Cap on a single Retry-After wait (default 60 s). */
+    maxRetryAfterMs?: number;
+    /** Backoff base when the server gives no Retry-After (default 1 s). */
+    baseDelayMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    /** Per-attempt timeout (default HOSTED_REQUEST_TIMEOUT_MS). */
+    timeoutMs?: number;
+    /** Sent as User-Agent. */
+    userAgent?: string;
+}
+export declare function parseRetryAfterMs(value: string | null): number | undefined;
+export declare class HostedTranslationProvider implements TranslationProvider {
+    /** Model the server reported (X-Babelize-Model), once a request succeeded. */
+    model?: string;
+    /** Set once a request fails in a way no retry can fix (bad key, no credits). */
+    fatalError?: HostedTranslationError;
+    private readonly opts;
+    constructor(options: HostedProviderOptions);
+    translateBatch(request: TranslationBatchRequest): Promise<KeyResult[]>;
+    private post;
+    private backoff;
+    private toError;
+}

package/dist/local/hosted-provider.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostedTranslationProvider = exports.HostedTranslationError = exports.BILLING_URL = exports.API_KEYS_URL = exports.HOSTED_MODEL_HEADER = exports.HOSTED_REQUEST_TIMEOUT_MS = exports.HOSTED_MAX_BATCH = void 0;
+exports.parseRetryAfterMs = parseRetryAfterMs;
+const node_crypto_1 = require("node:crypto");
+const language_codes_1 = require("../modules/translator/language-codes");
+const types_1 = require("@babelize/types");
+/**
+ * Babelize-hosted translation for `babelize translate`: a TranslationProvider
+ * that sends the engine's already placeholder-protected strings (never code)
+ * to POST {apiUrl}/v1/translate/batch with a Babelize API key. The engine
+ * still validates every result and runs its repair retry locally; model,
+ * quota and credits are decided by the server.
+ */
+/** Server limit on entries per request. */
+exports.HOSTED_MAX_BATCH = types_1.TRANSLATE_BATCH_LIMITS.maxEntries;
+/**
+ * Per-attempt timeout. Longer than the server's total model budget (90 s),
+ * so the server finishes — or gives up uncharged — before we retry.
+ */
+exports.HOSTED_REQUEST_TIMEOUT_MS = 150000;
+/** Response header naming the model that served a batch. */
+exports.HOSTED_MODEL_HEADER = 'x-babelize-model';
+exports.API_KEYS_URL = 'https://app.babelize.co/api-keys';
+exports.BILLING_URL = 'https://app.babelize.co/billing';
+class HostedTranslationError extends Error {
+    constructor(message, code, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = 'HostedTranslationError';
+    }
+    /** Errors after which no further request can succeed in this run. */
+    get fatal() {
+        return this.code === 'hosted_auth' || this.code === 'hosted_credits';
+    }
+}
+exports.HostedTranslationError = HostedTranslationError;
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+function parseRetryAfterMs(value) {
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds * 1000;
+    const date = Date.parse(value);
+    return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
+}
+class HostedTranslationProvider {
+    constructor(options) {
+        this.opts = {
+            fetch: globalThis.fetch.bind(globalThis),
+            maxRetries: 3,
+            maxRetryAfterMs: 60000,
+            baseDelayMs: 1000,
+            sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+            timeoutMs: exports.HOSTED_REQUEST_TIMEOUT_MS,
+            ...options,
+            apiUrl: options.apiUrl.replace(/\/+$/, ''),
+        };
+    }
+    async translateBatch(request) {
+        // Strings over the server's limits never leave the machine: they fail
+        // locally, and the rest of the batch is still sent.
+        const local = new Map();
+        const sendable = request.entries.filter((e) => {
+            if (e.value.length > types_1.TRANSLATE_BATCH_LIMITS.maxTextChars || e.key.length > types_1.TRANSLATE_BATCH_LIMITS.maxKeyChars) {
+                local.set(e.key, {
+                    key: e.key,
+                    status: 'failed',
+                    reason: 'unsupported_by_provider',
+                    retryable: false,
+                    message: `longer than the hosted limit of ${types_1.TRANSLATE_BATCH_LIMITS.maxTextChars} characters — use your own LLM key for this string`,
+                });
+                return false;
+            }
+            return true;
+        });
+        const remote = new Map();
+        for (let i = 0; i < sendable.length; i += exports.HOSTED_MAX_BATCH) {
+            const entries = sendable.slice(i, i + exports.HOSTED_MAX_BATCH);
+            const keys = new Set(entries.map((e) => e.key));
+            const hints = request.hints
+                ? Object.fromEntries(Object.entries(request.hints).filter(([k]) => keys.has(k)))
+                : undefined;
+            for (const r of await this.post({ ...request, entries, hints }))
+                remote.set(r.key, r);
+        }
+        return request.entries.flatMap((e) => {
+            const r = local.get(e.key) ?? remote.get(e.key);
+            return r ? [r] : [];
+        });
+    }
+    async post(request) {
+        // After a bad key or empty balance every further request fails the same way.
+        if (this.fatalError)
+            throw this.fatalError;
+        // Optional extras are trimmed to the server's limits rather than failing
+        // the batch: they guide the model but aren't what gets translated.
+        const glossary = (request.glossary ?? [])
+            .filter((g) => g.term.length <= types_1.TRANSLATE_BATCH_LIMITS.maxGlossaryTermChars && g.translation.length <= types_1.TRANSLATE_BATCH_LIMITS.maxGlossaryTermChars)
+            .slice(0, types_1.TRANSLATE_BATCH_LIMITS.maxGlossary);
+        const hints = Object.fromEntries(Object.entries(request.hints ?? {}).map(([k, v]) => [k, v.slice(0, types_1.TRANSLATE_BATCH_LIMITS.maxHintChars)]));
+        const body = JSON.stringify({
+            sourceLocale: isoOf(request.sourceLang),
+            targetLocale: request.targetLocale || isoOf(request.targetLang),
+            entries: request.entries.map((e) => {
+                const element = e.extractionContext?.replace(/^hardcoded-/, '');
+                return {
+                    key: e.key,
+                    text: e.value,
+                    ...(e.parentContext && e.parentContext.length <= types_1.TRANSLATE_BATCH_LIMITS.maxContextChars ? { context: e.parentContext } : {}),
+                    ...(element && element.length <= types_1.TRANSLATE_BATCH_LIMITS.maxElementChars ? { element } : {}),
+                };
+            }),
+            ...(glossary.length ? { glossary } : {}),
+            ...(Object.keys(hints).length > 0 ? { hints } : {}),
+            ...(request.brandVoice ? { brandVoice: request.brandVoice.slice(0, types_1.TRANSLATE_BATCH_LIMITS.maxBrandVoiceChars) } : {}),
+        });
+        // One key per logical batch, reused by its retries: if an earlier attempt
+        // was answered (and charged) but the response was lost, the server
+        // replays it instead of translating and charging again.
+        const idempotencyKey = (0, node_crypto_1.randomUUID)();
+        let attempt = 0;
+        for (;;) {
+            let res;
+            try {
+                res = await this.opts.fetch(`${this.opts.apiUrl}/v1/translate/batch`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${this.opts.apiKey}`,
+                        'Idempotency-Key': idempotencyKey,
+                        ...(this.opts.userAgent ? { 'User-Agent': this.opts.userAgent } : {}),
+                    },
+                    body,
+                    signal: AbortSignal.timeout(this.opts.timeoutMs),
+                });
+            }
+            catch (err) {
+                if (attempt < this.opts.maxRetries) {
+                    await this.opts.sleep(this.backoff(attempt++));
+                    continue;
+                }
+                throw new HostedTranslationError(`Could not reach Babelize at ${this.opts.apiUrl} (${err.message}).`, 'hosted_unavailable');
+            }
+            if (res.ok) {
+                let data;
+                try {
+                    data = (await res.json());
+                }
+                catch (err) {
+                    // The connection dropped (or the timeout fired) while the body was
+                    // being read. The server has already charged this batch, so retry
+                    // with the same Idempotency-Key: it replays the stored response.
+                    if (attempt < this.opts.maxRetries) {
+                        await this.opts.sleep(this.backoff(attempt++));
+                        continue;
+                    }
+                    throw new HostedTranslationError(`Lost the response from Babelize at ${this.opts.apiUrl} (${err.message}).`, 'hosted_unavailable');
+                }
+                this.model = res.headers.get(exports.HOSTED_MODEL_HEADER) ?? this.model;
+                return Array.isArray(data.results) ? data.results : [];
+            }
+            if (RETRYABLE_STATUS.has(res.status) && attempt < this.opts.maxRetries && !(await isHostedOff(res))) {
+                const retryAfter = parseRetryAfterMs(res.headers.get('retry-after'));
+                await this.opts.sleep(Math.min(retryAfter ?? this.backoff(attempt), this.opts.maxRetryAfterMs));
+                attempt++;
+                continue;
+            }
+            const error = await this.toError(res);
+            if (error.fatal)
+                this.fatalError = error;
+            throw error;
+        }
+    }
+    backoff(attempt) {
+        return this.opts.baseDelayMs * 2 ** attempt;
+    }
+    async toError(res) {
+        const payload = (await res.clone().json().catch(() => null));
+        const serverMessage = payload?.message ? ` (${payload.message})` : '';
+        switch (res.status) {
+            case 401:
+            case 403:
+                return new HostedTranslationError(`BABELIZE_API_KEY was rejected (${res.status}). Create a new key at ${exports.API_KEYS_URL} and set BABELIZE_API_KEY.`, 'hosted_auth', res.status);
+            case 402:
+                return new HostedTranslationError(payload?.message ??
+                    `Your Babelize account is out of AI credits. Top up or upgrade at ${exports.BILLING_URL}, or use your own LLM key (e.g. set ANTHROPIC_API_KEY).`, 'hosted_credits', 402);
+            case 429:
+                return new HostedTranslationError('Babelize rate limit reached and retries ran out. Wait a minute and run translate again.', 'hosted_rate_limited', 429);
+            case 400:
+                return new HostedTranslationError(`Babelize rejected the request${serverMessage}.`, 'hosted_bad_request', 400);
+            default:
+                return new HostedTranslationError(`Babelize-hosted translation is unavailable (${res.status})${serverMessage}. Try again later or use your own LLM key.`, 'hosted_unavailable', res.status);
+        }
+    }
+}
+exports.HostedTranslationProvider = HostedTranslationProvider;
+/** A 503 that means "hosted is switched off" won't get better by retrying. */
+async function isHostedOff(res) {
+    if (res.status !== 503)
+        return false;
+    const payload = (await res.clone().json().catch(() => null));
+    return payload?.error === 'hosted_translation_unavailable';
+}
+/** eng_Latn → en (the engine passes FLORES codes; the API takes ISO). */
+function isoOf(flores) {
+    try {
+        return (0, language_codes_1.fromFlores)(flores);
+    }
+    catch {
+        return flores;
+    }
+}

package/dist/local/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Local translation runner: what `babelize translate` and the MCP
+ * `babelize_translate` tool run on the user's machine. Git checks, a temp
+ * copy, the engine run, apply-back with concurrent-edit detection, provider
+ * resolution (BYOK env keys or the Babelize-hosted provider) and the report.
+ */
+export { BETA_LOCAL_FRAMEWORKS, buildLocaleReports, isEngineLogNoise, LOCAL_LOCKFILE, LOCAL_PROJECT_ID, LocalTranslateError, parseLocales, runLocalTranslate, sentence, SUPPORTED_LOCAL_FRAMEWORKS, validateLocales, } from './translate-core';
+export type { FrameworkStatus, LocaleReport, LocalTranslateDeps, LocalTranslateErrorCode, LocalTranslateOptions, LocalTranslateReport, ReportProviderId, } from './translate-core';
+export { BABELIZE_GITIGNORE, buildTranslateReport, DEFAULT_REPORT_FILE, ensureReportGitignored, TRANSLATE_REPORT_SCHEMA_ID, TRANSLATE_REPORT_SCHEMA_VERSION, writeTranslateReport, } from './report';
+export type { KeyStatus, TranslateReport, TranslateReportKeyLocale, TranslateReportLocale } from './report';
+export { isPseudoLocalized, PSEUDO_CLOSE, PSEUDO_OPEN, PseudoTranslationProvider } from './pseudo-provider';
+export { translateMessages } from './translate-messages';
+export type { TranslateMessagesOptions, TranslateMessagesResult } from './translate-messages';
+export type { PseudoProviderOptions } from './pseudo-provider';
+export { BABELIZE_KEY_ENV_VAR, HOSTED_PROVIDER_ID, isByokProvider, isHostedResolution, noKeyMessage, PROVIDER_ENV_VARS, resolveProvider, } from './provider';
+export type { ProviderResolution, ResolvedHostedProvider, ResolvedProvider, ResolvedTranslator } from './provider';
+export { API_KEYS_URL, BILLING_URL, HOSTED_MAX_BATCH, HOSTED_MODEL_HEADER, HOSTED_REQUEST_TIMEOUT_MS, HostedTranslationError, HostedTranslationProvider, parseRetryAfterMs, } from './hosted-provider';
+export type { HostedErrorCode, HostedProviderOptions } from './hosted-provider';
+export { assertCleanTree, assertGitRepo, getUncommittedChanges, GitError, isBabelizeReportFile, isGitIgnored } from './git';
+export { detectFormatter, formatChangedFiles } from './formatter';
+export type { FormatResult, FormatterName } from './formatter';
+export { ApplyError, applyChanges, changeCount, createTempCopy, diffSnapshots, diffStats, findConflicts, listGitFiles, renderUnifiedDiff, snapshot, } from './workspace-copy';
+export type { ApplyIo, FileDiffStat, TempWorkspace, WorkspaceChanges } from './workspace-copy';

package/dist/local/index.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTempCopy = exports.changeCount = exports.applyChanges = exports.ApplyError = exports.formatChangedFiles = exports.detectFormatter = exports.isGitIgnored = exports.isBabelizeReportFile = exports.GitError = exports.getUncommittedChanges = exports.assertGitRepo = exports.assertCleanTree = exports.parseRetryAfterMs = exports.HostedTranslationProvider = exports.HostedTranslationError = exports.HOSTED_REQUEST_TIMEOUT_MS = exports.HOSTED_MODEL_HEADER = exports.HOSTED_MAX_BATCH = exports.BILLING_URL = exports.API_KEYS_URL = exports.resolveProvider = exports.PROVIDER_ENV_VARS = exports.noKeyMessage = exports.isHostedResolution = exports.isByokProvider = exports.HOSTED_PROVIDER_ID = exports.BABELIZE_KEY_ENV_VAR = exports.translateMessages = exports.PseudoTranslationProvider = exports.PSEUDO_OPEN = exports.PSEUDO_CLOSE = exports.isPseudoLocalized = exports.writeTranslateReport = exports.TRANSLATE_REPORT_SCHEMA_VERSION = exports.TRANSLATE_REPORT_SCHEMA_ID = exports.ensureReportGitignored = exports.DEFAULT_REPORT_FILE = exports.buildTranslateReport = exports.BABELIZE_GITIGNORE = exports.validateLocales = exports.SUPPORTED_LOCAL_FRAMEWORKS = exports.sentence = exports.runLocalTranslate = exports.parseLocales = exports.LocalTranslateError = exports.LOCAL_PROJECT_ID = exports.LOCAL_LOCKFILE = exports.isEngineLogNoise = exports.buildLocaleReports = exports.BETA_LOCAL_FRAMEWORKS = void 0;
+exports.snapshot = exports.renderUnifiedDiff = exports.listGitFiles = exports.findConflicts = exports.diffStats = exports.diffSnapshots = void 0;
+/**
+ * Local translation runner: what `babelize translate` and the MCP
+ * `babelize_translate` tool run on the user's machine. Git checks, a temp
+ * copy, the engine run, apply-back with concurrent-edit detection, provider
+ * resolution (BYOK env keys or the Babelize-hosted provider) and the report.
+ */
+var translate_core_1 = require("./translate-core");
+Object.defineProperty(exports, "BETA_LOCAL_FRAMEWORKS", { enumerable: true, get: function () { return translate_core_1.BETA_LOCAL_FRAMEWORKS; } });
+Object.defineProperty(exports, "buildLocaleReports", { enumerable: true, get: function () { return translate_core_1.buildLocaleReports; } });
+Object.defineProperty(exports, "isEngineLogNoise", { enumerable: true, get: function () { return translate_core_1.isEngineLogNoise; } });
+Object.defineProperty(exports, "LOCAL_LOCKFILE", { enumerable: true, get: function () { return translate_core_1.LOCAL_LOCKFILE; } });
+Object.defineProperty(exports, "LOCAL_PROJECT_ID", { enumerable: true, get: function () { return translate_core_1.LOCAL_PROJECT_ID; } });
+Object.defineProperty(exports, "LocalTranslateError", { enumerable: true, get: function () { return translate_core_1.LocalTranslateError; } });
+Object.defineProperty(exports, "parseLocales", { enumerable: true, get: function () { return translate_core_1.parseLocales; } });
+Object.defineProperty(exports, "runLocalTranslate", { enumerable: true, get: function () { return translate_core_1.runLocalTranslate; } });
+Object.defineProperty(exports, "sentence", { enumerable: true, get: function () { return translate_core_1.sentence; } });
+Object.defineProperty(exports, "SUPPORTED_LOCAL_FRAMEWORKS", { enumerable: true, get: function () { return translate_core_1.SUPPORTED_LOCAL_FRAMEWORKS; } });
+Object.defineProperty(exports, "validateLocales", { enumerable: true, get: function () { return translate_core_1.validateLocales; } });
+var report_1 = require("./report");
+Object.defineProperty(exports, "BABELIZE_GITIGNORE", { enumerable: true, get: function () { return report_1.BABELIZE_GITIGNORE; } });
+Object.defineProperty(exports, "buildTranslateReport", { enumerable: true, get: function () { return report_1.buildTranslateReport; } });
+Object.defineProperty(exports, "DEFAULT_REPORT_FILE", { enumerable: true, get: function () { return report_1.DEFAULT_REPORT_FILE; } });
+Object.defineProperty(exports, "ensureReportGitignored", { enumerable: true, get: function () { return report_1.ensureReportGitignored; } });
+Object.defineProperty(exports, "TRANSLATE_REPORT_SCHEMA_ID", { enumerable: true, get: function () { return report_1.TRANSLATE_REPORT_SCHEMA_ID; } });
+Object.defineProperty(exports, "TRANSLATE_REPORT_SCHEMA_VERSION", { enumerable: true, get: function () { return report_1.TRANSLATE_REPORT_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "writeTranslateReport", { enumerable: true, get: function () { return report_1.writeTranslateReport; } });
+var pseudo_provider_1 = require("./pseudo-provider");
+Object.defineProperty(exports, "isPseudoLocalized", { enumerable: true, get: function () { return pseudo_provider_1.isPseudoLocalized; } });
+Object.defineProperty(exports, "PSEUDO_CLOSE", { enumerable: true, get: function () { return pseudo_provider_1.PSEUDO_CLOSE; } });
+Object.defineProperty(exports, "PSEUDO_OPEN", { enumerable: true, get: function () { return pseudo_provider_1.PSEUDO_OPEN; } });
+Object.defineProperty(exports, "PseudoTranslationProvider", { enumerable: true, get: function () { return pseudo_provider_1.PseudoTranslationProvider; } });
+var translate_messages_1 = require("./translate-messages");
+Object.defineProperty(exports, "translateMessages", { enumerable: true, get: function () { return translate_messages_1.translateMessages; } });
+var provider_1 = require("./provider");
+Object.defineProperty(exports, "BABELIZE_KEY_ENV_VAR", { enumerable: true, get: function () { return provider_1.BABELIZE_KEY_ENV_VAR; } });
+Object.defineProperty(exports, "HOSTED_PROVIDER_ID", { enumerable: true, get: function () { return provider_1.HOSTED_PROVIDER_ID; } });
+Object.defineProperty(exports, "isByokProvider", { enumerable: true, get: function () { return provider_1.isByokProvider; } });
+Object.defineProperty(exports, "isHostedResolution", { enumerable: true, get: function () { return provider_1.isHostedResolution; } });
+Object.defineProperty(exports, "noKeyMessage", { enumerable: true, get: function () { return provider_1.noKeyMessage; } });
+Object.defineProperty(exports, "PROVIDER_ENV_VARS", { enumerable: true, get: function () { return provider_1.PROVIDER_ENV_VARS; } });
+Object.defineProperty(exports, "resolveProvider", { enumerable: true, get: function () { return provider_1.resolveProvider; } });
+var hosted_provider_1 = require("./hosted-provider");
+Object.defineProperty(exports, "API_KEYS_URL", { enumerable: true, get: function () { return hosted_provider_1.API_KEYS_URL; } });
+Object.defineProperty(exports, "BILLING_URL", { enumerable: true, get: function () { return hosted_provider_1.BILLING_URL; } });
+Object.defineProperty(exports, "HOSTED_MAX_BATCH", { enumerable: true, get: function () { return hosted_provider_1.HOSTED_MAX_BATCH; } });
+Object.defineProperty(exports, "HOSTED_MODEL_HEADER", { enumerable: true, get: function () { return hosted_provider_1.HOSTED_MODEL_HEADER; } });
+Object.defineProperty(exports, "HOSTED_REQUEST_TIMEOUT_MS", { enumerable: true, get: function () { return hosted_provider_1.HOSTED_REQUEST_TIMEOUT_MS; } });
+Object.defineProperty(exports, "HostedTranslationError", { enumerable: true, get: function () { return hosted_provider_1.HostedTranslationError; } });
+Object.defineProperty(exports, "HostedTranslationProvider", { enumerable: true, get: function () { return hosted_provider_1.HostedTranslationProvider; } });
+Object.defineProperty(exports, "parseRetryAfterMs", { enumerable: true, get: function () { return hosted_provider_1.parseRetryAfterMs; } });
+var git_1 = require("./git");
+Object.defineProperty(exports, "assertCleanTree", { enumerable: true, get: function () { return git_1.assertCleanTree; } });
+Object.defineProperty(exports, "assertGitRepo", { enumerable: true, get: function () { return git_1.assertGitRepo; } });
+Object.defineProperty(exports, "getUncommittedChanges", { enumerable: true, get: function () { return git_1.getUncommittedChanges; } });
+Object.defineProperty(exports, "GitError", { enumerable: true, get: function () { return git_1.GitError; } });
+Object.defineProperty(exports, "isBabelizeReportFile", { enumerable: true, get: function () { return git_1.isBabelizeReportFile; } });
+Object.defineProperty(exports, "isGitIgnored", { enumerable: true, get: function () { return git_1.isGitIgnored; } });
+var formatter_1 = require("./formatter");
+Object.defineProperty(exports, "detectFormatter", { enumerable: true, get: function () { return formatter_1.detectFormatter; } });
+Object.defineProperty(exports, "formatChangedFiles", { enumerable: true, get: function () { return formatter_1.formatChangedFiles; } });
+var workspace_copy_1 = require("./workspace-copy");
+Object.defineProperty(exports, "ApplyError", { enumerable: true, get: function () { return workspace_copy_1.ApplyError; } });
+Object.defineProperty(exports, "applyChanges", { enumerable: true, get: function () { return workspace_copy_1.applyChanges; } });
+Object.defineProperty(exports, "changeCount", { enumerable: true, get: function () { return workspace_copy_1.changeCount; } });
+Object.defineProperty(exports, "createTempCopy", { enumerable: true, get: function () { return workspace_copy_1.createTempCopy; } });
+Object.defineProperty(exports, "diffSnapshots", { enumerable: true, get: function () { return workspace_copy_1.diffSnapshots; } });
+Object.defineProperty(exports, "diffStats", { enumerable: true, get: function () { return workspace_copy_1.diffStats; } });
+Object.defineProperty(exports, "findConflicts", { enumerable: true, get: function () { return workspace_copy_1.findConflicts; } });
+Object.defineProperty(exports, "listGitFiles", { enumerable: true, get: function () { return workspace_copy_1.listGitFiles; } });
+Object.defineProperty(exports, "renderUnifiedDiff", { enumerable: true, get: function () { return workspace_copy_1.renderUnifiedDiff; } });
+Object.defineProperty(exports, "snapshot", { enumerable: true, get: function () { return workspace_copy_1.snapshot; } });

package/dist/local/provider.d.ts

@@ -0,0 +1,56 @@
+import { type ByokProvider } from '@babelize/types';
+/**
+ * Env var holding each provider's key, in auto-detection order: the first one
+ * set wins when `--provider` isn't given.
+ */
+export declare const PROVIDER_ENV_VARS: ReadonlyArray<{
+    provider: ByokProvider;
+    envVar: string;
+}>;
+export interface ResolvedProvider {
+    provider: ByokProvider;
+    /** Never print this. */
+    apiKey: string;
+    model: string;
+    /** Env var the key came from (safe to print). */
+    envVar: string;
+    /** True when the provider was picked from the environment, not `--provider`. */
+    autoDetected: boolean;
+}
+/** Env var holding a Babelize API key for hosted translation. */
+export declare const BABELIZE_KEY_ENV_VAR = "BABELIZE_API_KEY";
+/** `--provider` value selecting Babelize-hosted translation. */
+export declare const HOSTED_PROVIDER_ID = "babelize";
+/** Babelize-hosted translation: the server picks the model and bills credits. */
+export interface ResolvedHostedProvider {
+    provider: typeof HOSTED_PROVIDER_ID;
+    /** Never print this. */
+    apiKey: string;
+    envVar: typeof BABELIZE_KEY_ENV_VAR;
+    autoDetected: boolean;
+}
+export type ResolvedTranslator = ResolvedProvider | ResolvedHostedProvider;
+export declare function isHostedResolution(r: ResolvedTranslator): r is ResolvedHostedProvider;
+export type ProviderResolution = {
+    ok: true;
+    value: ResolvedTranslator;
+} | {
+    ok: false;
+    code: 'unknown_provider' | 'missing_key' | 'no_key' | 'model_not_supported';
+    message: string;
+};
+export declare function isByokProvider(value: string): value is ByokProvider;
+/** Message shown when no key is available. Lists env vars, never values. */
+export declare function noKeyMessage(): string;
+/**
+ * Pick the translator, in order of precedence:
+ * 1. `--provider` (a BYOK vendor, or `babelize`); its env var must be set.
+ * 2. The first BYOK env var set, in PROVIDER_ENV_VARS order.
+ * 3. BABELIZE_API_KEY → Babelize-hosted translation.
+ * For BYOK the model is `--model` or the provider's default from
+ * @babelize/types; hosted translation's model is chosen by the server.
+ */
+export declare function resolveProvider(opts: {
+    provider?: string;
+    model?: string;
+}, env?: NodeJS.ProcessEnv): ProviderResolution;