@babelize/engine 0.0.0-stage → 0.1.0

package/dist/qa/locale-qa.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenLocaleMessages = flattenLocaleMessages;
+exports.checkLocalePair = checkLocalePair;
+exports.tallyLocaleIssues = tallyLocaleIssues;
+/**
+ * QA of an existing target locale against its source locale, without
+ * translating anything: missing/extra keys, empty and untranslated values,
+ * lost or invented placeholders, broken ICU messages and wrong plural forms
+ * (ICU and i18next `_one`/`_other` suffix keys), and glossary violations.
+ *
+ * Pure: takes flat key → text maps, returns issues in plain words. Used by the
+ * MCP `babelize_check` / `babelize_review` tools; the checks are the same ones
+ * the translate phase applies to fresh translations (placeholder protection,
+ * ICU comparison).
+ */
+const icu_message_1 = require("../utils/icu-message");
+const glossary_match_1 = require("../utils/glossary-match");
+const placeholder_protection_1 = require("../utils/placeholder-protection");
+const pseudo_markers_1 = require("../utils/pseudo-markers");
+const icu_spans_1 = require("../utils/icu-spans");
+const PLURAL_CATEGORIES = ['zero', 'one', 'two', 'few', 'many', 'other'];
+const PLURAL_SUFFIX = /^(.+)_(zero|one|two|few|many|other)$/;
+/**
+ * Flatten nested locale JSON into dotted keys with string values. The
+ * engine's `_meta` block is dropped; non-string leaves (numbers, arrays) are
+ * not messages and are skipped.
+ */
+function flattenLocaleMessages(data, prefix = '', out = {}) {
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return out;
+    for (const [k, v] of Object.entries(data)) {
+        if (!prefix && k === '_meta')
+            continue;
+        const key = prefix ? `${prefix}.${k}` : k;
+        if (typeof v === 'string')
+            out[key] = v;
+        else if (v && typeof v === 'object' && !Array.isArray(v))
+            flattenLocaleMessages(v, key, out);
+    }
+    return out;
+}
+function hasLetters(text) {
+    return /\p{L}/u.test(text);
+}
+function language(locale) {
+    return locale.toLowerCase().split(/[-_]/)[0];
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function containsTerm(text, term, ignoreCase) {
+    return new RegExp(`(?<![\\p{L}\\p{N}_])${escapeRegex(term)}(?![\\p{L}\\p{N}_])`, ignoreCase ? 'iu' : 'u').test(text);
+}
+/** Protected spans (variables, tags, URLs, …) with how often each occurs. */
+function spanCounts(text, icu) {
+    const counts = new Map();
+    for (const span of (0, placeholder_protection_1.protectText)(text, [], { icu }).tokens) {
+        // Whitespace inside a variable is not meaningful ({ name } == {name}).
+        const norm = /^[{%$]/.test(span) ? span.replace(/\s+/g, '') : span;
+        counts.set(norm, (counts.get(norm) ?? 0) + 1);
+    }
+    return counts;
+}
+/** Variables and tags break the UI when lost; a changed URL or email may be deliberate. */
+function isStructural(span) {
+    return /^[{%$<]/.test(span);
+}
+function quoteList(spans) {
+    return spans.map((s) => (s.length > 40 ? `${s.slice(0, 37)}…` : s)).join(', ');
+}
+function icuIssueCode(issue) {
+    switch (issue.code) {
+        case 'icu_invalid':
+            return 'icu_invalid';
+        case 'icu_plural_category_invalid':
+            return 'plural_category_invalid';
+        case 'icu_plural_category_missing':
+            return 'plural_category_missing';
+        default:
+            return 'icu_mismatch';
+    }
+}
+const COUNT_SPAN = /^\{\{?-?\s*count\s*\}?\}$/;
+function pluralSpans(forms) {
+    const counts = forms.map((f) => spanCounts(f, false));
+    const required = new Map();
+    const allowed = new Set();
+    for (const c of counts)
+        for (const span of c.keys())
+            allowed.add(span);
+    for (const span of allowed) {
+        if (COUNT_SPAN.test(span))
+            continue;
+        const min = Math.min(...counts.map((c) => c.get(span) ?? 0));
+        if (min > 0)
+            required.set(span, min);
+    }
+    return { required, allowed };
+}
+function checkValue(key, source, target, locale, options, push, plural) {
+    if (target.trim() === '') {
+        if (source.trim() !== '')
+            push({ key, code: 'empty_value', severity: 'error', message: 'Value is empty; the app shows a blank string.' });
+        return;
+    }
+    if ((0, pseudo_markers_1.isPseudoLocalized)(target) && !(0, pseudo_markers_1.isPseudoLocalized)(source)) {
+        push({
+            key,
+            code: 'pseudo_translation',
+            severity: 'error',
+            message: 'Pseudo-localized test text (⟦…⟧ from --provider pseudo), not a translation. Run babelize translate with a real provider to replace it.',
+        });
+    }
+    const icu = (0, icu_message_1.isIcuMessage)(source) || (0, icu_message_1.isIcuMessage)(target);
+    if (icu) {
+        // The translate phase lets a translation add a plural over a count-like
+        // argument of a plain source ("{unreadCount} notes" → German one/other);
+        // QA accepts the same, or a correct run would fail `babelize check`.
+        const pluralizable = (0, icu_message_1.isIcuMessage)(source) ? [] : (0, icu_message_1.countArguments)(source);
+        for (const issue of (0, icu_message_1.compareIcuMessages)(source, target, locale, { pluralizable })) {
+            push({ key, code: icuIssueCode(issue), severity: issue.severity, message: `${issue.message.charAt(0).toUpperCase()}${issue.message.slice(1)}.` });
+        }
+    }
+    // Placeholders, tags, URLs: every span in the source must be in the
+    // translation exactly as often (in ICU messages braces are structure and
+    // were compared above, so only tags/URLs/code are counted).
+    const tgt = spanCounts(target, icu);
+    const lost = [];
+    const added = [];
+    if (plural && !icu) {
+        // A plural form is checked against all of the key's source forms.
+        for (const [span, n] of plural.required)
+            if ((tgt.get(span) ?? 0) < n)
+                lost.push(span);
+        for (const span of tgt.keys())
+            if (!plural.allowed.has(span) && !COUNT_SPAN.test(span))
+                added.push(span);
+    }
+    else if (icu) {
+        // An ICU message repeats a tag once per branch, and a plural added over a
+        // plain source does too: compare which spans appear, not how often (as
+        // the translate phase does).
+        const src = spanCounts(source, icu);
+        for (const span of src.keys())
+            if (!tgt.has(span))
+                lost.push(span);
+        for (const span of tgt.keys())
+            if (!src.has(span))
+                added.push(span);
+    }
+    else {
+        const src = spanCounts(source, icu);
+        for (const [span, n] of src)
+            if ((tgt.get(span) ?? 0) < n)
+                lost.push(span);
+        for (const [span, n] of tgt)
+            if ((src.get(span) ?? 0) < n)
+                added.push(span);
+    }
+    if (lost.length || added.length) {
+        const structural = [...lost, ...added].some(isStructural);
+        const parts = [
+            lost.length ? `lost ${quoteList(lost)}` : '',
+            added.length ? `added ${quoteList(added)}` : '',
+        ].filter(Boolean);
+        push({
+            key,
+            code: 'placeholder_mismatch',
+            severity: structural ? 'error' : 'warning',
+            message: `Placeholders differ from the source: ${parts.join('; ')}.`,
+        });
+    }
+    else if (icu) {
+        // Present somewhere is not enough: each branch must carry its source
+        // branch's spans (or the whole plain source, for an added plural).
+        const branch = (0, icu_spans_1.branchSpanProblems)(source, target);
+        if (branch.length) {
+            const all = branch.flatMap((p) => [...p.lost, ...p.added]);
+            push({
+                key,
+                code: 'placeholder_mismatch',
+                severity: all.some(isStructural) ? 'error' : 'warning',
+                message: `Placeholders differ from the source in ${branch.map(icu_spans_1.describeBranchSpanProblem).join('; ')}.`,
+            });
+        }
+    }
+    const neverTranslate = options.glossary?.neverTranslate ?? [];
+    if (target === source &&
+        hasLetters(source) &&
+        !(options.sourceLocale && language(options.sourceLocale) === language(locale)) &&
+        hasLetters((0, placeholder_protection_1.protectText)(source, neverTranslate, { icu }).text.replace(/\[#VAR_\d+#\]/g, ''))) {
+        const words = source.trim().split(/\s+/).filter(hasLetters).length;
+        push({
+            key,
+            code: 'untranslated',
+            severity: words >= 2 ? 'warning' : 'info',
+            message: words >= 2
+                ? 'Same text as the source; looks untranslated.'
+                : 'Same text as the source (fine for names or codes, otherwise untranslated).',
+        });
+    }
+    for (const term of neverTranslate) {
+        if (term.trim() && containsTerm(source, term, false) && !containsTerm(target, term, false)) {
+            push({ key, code: 'glossary_violation', severity: 'warning', message: `"${term}" must stay untranslated but is missing from the translation.` });
+        }
+    }
+    for (const entry of options.glossary?.alwaysTranslateAs ?? []) {
+        const expected = entry.translations[locale] ?? entry.translations[language(locale)];
+        if (!expected || !entry.term.trim())
+            continue;
+        // Same matcher as the translate phase: inflected forms count (Polish "obszaru roboczego").
+        if (containsTerm(source, entry.term, true) && !(0, glossary_match_1.containsGlossaryTranslation)(target, expected)) {
+            push({ key, code: 'glossary_violation', severity: 'warning', message: `"${entry.term}" should be translated as "${expected}".` });
+        }
+    }
+}
+/** Plural groups (i18next `key_one` / `key_other`) in a flat map: base → category → key. */
+function pluralGroups(flat) {
+    const groups = new Map();
+    for (const key of Object.keys(flat)) {
+        const m = PLURAL_SUFFIX.exec(key);
+        if (!m)
+            continue;
+        const group = groups.get(m[1]) ?? new Map();
+        group.set(m[2], key);
+        groups.set(m[1], group);
+    }
+    return groups;
+}
+/**
+ * Check one target locale against the source locale. Both maps are flat
+ * (see {@link flattenLocaleMessages}). Issues come in key order, errors and
+ * warnings mixed; callers cap and sort as they need.
+ */
+function checkLocalePair(source, target, locale, options = {}) {
+    const issues = [];
+    const push = (issue) => issues.push({ locale, ...issue });
+    const only = options.keys ? new Set(options.keys) : null;
+    const inScope = (key) => !only || only.has(key);
+    // A suffix group counts as plural only when the source has its `_other`
+    // form; `step_one` alone is just a key name.
+    const sourceGroups = new Map([...pluralGroups(source)].filter(([, g]) => g.has('other')));
+    const targetGroups = pluralGroups(target);
+    const pluralKeys = new Set();
+    for (const [base, group] of sourceGroups) {
+        for (const key of group.values())
+            pluralKeys.add(key);
+        for (const key of targetGroups.get(base)?.values() ?? [])
+            pluralKeys.add(key);
+    }
+    let total = 0;
+    let translated = 0;
+    for (const key of Object.keys(source)) {
+        if (pluralKeys.has(key) || !inScope(key))
+            continue;
+        total++;
+        const value = target[key];
+        if (value === undefined) {
+            push({ key, code: 'missing_key', severity: 'error', message: 'Missing in this locale; the app falls back to the source text.' });
+            continue;
+        }
+        if (value.trim() !== '')
+            translated++;
+        checkValue(key, source[key], value, locale, options, push);
+    }
+    const required = (0, icu_message_1.requiredPluralCategories)(locale).cardinal;
+    for (const [base, group] of sourceGroups) {
+        const groupKeys = [...group.values(), ...(targetGroups.get(base)?.values() ?? [])];
+        if (only && !groupKeys.some((k) => only.has(k)))
+            continue;
+        total++;
+        const label = `${base}_*`;
+        const present = targetGroups.get(base) ?? new Map();
+        if (present.size === 0) {
+            push({ key: label, code: 'missing_key', severity: 'error', message: 'Plural forms are missing in this locale; the app falls back to the source text.' });
+            continue;
+        }
+        translated++;
+        const missing = required.filter((c) => !present.has(c));
+        if (missing.length) {
+            push({
+                key: label,
+                code: 'plural_category_missing',
+                severity: 'error',
+                message: `Missing plural form${missing.length > 1 ? 's' : ''} ${missing.map((c) => `_${c}`).join(', ')} that ${locale} needs; those counts fall back to the source text.`,
+            });
+        }
+        // i18next resolves `_zero` for count 0 in every language: never unused.
+        const unused = [...present.keys()].filter((c) => c !== 'zero' && !required.includes(c) && PLURAL_CATEGORIES.includes(c));
+        if (unused.length) {
+            push({
+                key: label,
+                code: 'plural_category_invalid',
+                severity: 'warning',
+                message: `Has plural form${unused.length > 1 ? 's' : ''} ${unused.map((c) => `_${c}`).join(', ')}, which ${locale} doesn't use (valid: ${required.join(', ')}).`,
+            });
+        }
+        const spans = pluralSpans([...group.values()].map((k) => source[k]));
+        for (const [category, key] of present) {
+            const src = source[group.get(category) ?? group.get('other')];
+            checkValue(key, src, target[key], locale, options, push, spans);
+        }
+    }
+    for (const key of Object.keys(target)) {
+        if (key in source || pluralKeys.has(key) || !inScope(key))
+            continue;
+        push({ key, code: 'extra_key', severity: 'info', message: 'Not in the source locale (stale or renamed key).' });
+    }
+    return tallyLocaleIssues({ locale, total, translated, counts: {}, errors: 0, warnings: 0, issues });
+}
+/** Recompute `counts`/`errors`/`warnings` from `issues` (after adding issues to a report). */
+function tallyLocaleIssues(report) {
+    const counts = {};
+    let errors = 0;
+    let warnings = 0;
+    for (const issue of report.issues) {
+        counts[issue.code] = (counts[issue.code] ?? 0) + 1;
+        if (issue.severity === 'error')
+            errors++;
+        else if (issue.severity === 'warning')
+            warnings++;
+    }
+    return { ...report, counts, errors, warnings };
+}

package/dist/qa/review.d.ts

@@ -0,0 +1,43 @@
+import { type FindLocaleOptions, type LocaleFileSet } from './locale-files';
+import { type LocaleGlossary, type LocalePairReport } from './locale-qa';
+export interface ReviewOptions {
+    /** Ref to compare against (branch, tag, commit). Default HEAD (uncommitted changes). */
+    base?: string;
+    sourceLocale?: string;
+    /** Only these target locales. */
+    locales?: string[];
+    glossary?: LocaleGlossary;
+    /** Directory names skipped when looking for locale files. */
+    ignoreDirs?: FindLocaleOptions['ignoreDirs'];
+}
+export interface LocaleSetChangeReview {
+    dir: string;
+    layout: LocaleFileSet['layout'];
+    sourceLocale: string;
+    /** Source-locale keys added, changed and removed by the diff. */
+    source: {
+        added: string[];
+        changed: string[];
+        removed: string[];
+    };
+    /** Target locales touched by the diff (or affected by source changes). */
+    locales: Array<LocalePairReport & {
+        changedKeys: number;
+        removedKeys: number;
+        fileDeleted: boolean;
+    }>;
+}
+export interface LocaleChangeReview {
+    /** What the working tree was compared with. */
+    base: string;
+    /** Changed locale files, relative to the project. */
+    changedLocaleFiles: string[];
+    /** Other changed files (code), relative to the project. */
+    changedOtherFiles: number;
+    sets: LocaleSetChangeReview[];
+}
+export declare class ReviewError extends Error {
+    readonly code: 'not_a_repo' | 'git_missing' | 'bad_base';
+    constructor(message: string, code: 'not_a_repo' | 'git_missing' | 'bad_base');
+}
+export declare function reviewLocaleChanges(projectDir: string, options?: ReviewOptions): Promise<LocaleChangeReview>;

package/dist/qa/review.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewError = void 0;
+exports.reviewLocaleChanges = reviewLocaleChanges;
+/**
+ * Review the locale changes in a git diff: QA only the entries that changed
+ * (same checks as checkProjectLocales), plus source strings whose
+ * translations weren't updated and new source keys a locale is missing.
+ * Read-only; compares the working tree with HEAD or a base ref.
+ */
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const git_1 = require("../local/git");
+const check_project_1 = require("./check-project");
+const locale_files_1 = require("./locale-files");
+const locale_qa_1 = require("./locale-qa");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+class ReviewError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'ReviewError';
+    }
+}
+exports.ReviewError = ReviewError;
+/** Git's empty tree: the base of a repository without commits. */
+const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+async function git(cwd, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd, maxBuffer: 256 * 1024 * 1024 });
+    return stdout;
+}
+async function resolveBase(projectDir, base) {
+    if (base !== undefined) {
+        // A ref, never an option (`--output=…`) or a range.
+        if (!/^[\w./@^~{}-]+$/.test(base) || base.startsWith('-') || base.includes('..')) {
+            throw new ReviewError(`"${base}" is not a valid git ref.`, 'bad_base');
+        }
+        try {
+            const sha = (await git(projectDir, ['rev-parse', '--verify', '--quiet', '--end-of-options', `${base}^{commit}`])).trim();
+            return { ref: sha, label: base };
+        }
+        catch {
+            throw new ReviewError(`Unknown git ref "${base}". Use a branch, tag or commit (e.g. main, origin/main, HEAD~1).`, 'bad_base');
+        }
+    }
+    try {
+        const sha = (await git(projectDir, ['rev-parse', '--verify', '--quiet', 'HEAD^{commit}'])).trim();
+        return { ref: sha, label: 'HEAD' };
+    }
+    catch {
+        return { ref: EMPTY_TREE, label: 'empty repository' };
+    }
+}
+const lines = (out) => out.split('\n').map((l) => l.trim()).filter(Boolean);
+function diffKeys(now, old) {
+    const added = [];
+    const changed = [];
+    const removed = [];
+    for (const [k, v] of Object.entries(now)) {
+        if (!(k in old))
+            added.push(k);
+        else if (old[k] !== v)
+            changed.push(k);
+    }
+    for (const k of Object.keys(old))
+        if (!(k in now))
+            removed.push(k);
+    return { added, changed, removed };
+}
+function clip(text, max = 60) {
+    const one = text.replace(/\s+/g, ' ').trim();
+    return one.length > max ? `${one.slice(0, max - 1)}…` : one;
+}
+async function reviewLocaleChanges(projectDir, options = {}) {
+    try {
+        await (0, git_1.assertGitRepo)(projectDir);
+    }
+    catch (err) {
+        const code = err.code === 'git_missing' ? 'git_missing' : 'not_a_repo';
+        throw new ReviewError(err.message, code);
+    }
+    const { ref, label } = await resolveBase(projectDir, options.base);
+    // Paths relative to projectDir (--relative also limits the diff to it).
+    const changed = new Set([
+        ...lines(await git(projectDir, ['diff', '--name-only', '--relative', ref, '--', '.'])),
+        ...lines(await git(projectDir, ['ls-files', '--others', '--exclude-standard', '--', '.'])),
+    ]);
+    const readOld = async (rel) => {
+        if (ref === EMPTY_TREE)
+            return null;
+        try {
+            return await git(projectDir, ['show', `${ref}:./${rel}`]);
+        }
+        catch {
+            return null; // new file
+        }
+    };
+    const config = await (0, check_project_1.readProjectLocaleConfig)(projectDir);
+    // Sets from the working tree and the base, so deleted locale files count.
+    const basePaths = ref === EMPTY_TREE ? [] : lines(await git(projectDir, ['ls-tree', '-r', '--name-only', ref, '--', '.']));
+    const nowSets = await (0, locale_files_1.findLocaleFileSets)(projectDir, { ignoreDirs: options.ignoreDirs });
+    const sets = (0, locale_files_1.groupLocaleFiles)([...nowSets.flatMap((st) => Object.values(st.files).flat()), ...basePaths], { ignoreDirs: options.ignoreDirs });
+    const sourceLocale = options.sourceLocale ?? config.sourceLocale ?? 'en';
+    const glossary = options.glossary ?? config.glossary;
+    const localeFiles = new Set(sets.flatMap((st) => Object.values(st.files).flat()));
+    const reviews = [];
+    for (const set of sets) {
+        const setFiles = Object.values(set.files).flat();
+        if (!set.files[sourceLocale] || !setFiles.some((f) => changed.has(f)))
+            continue;
+        const srcNow = (await (0, locale_files_1.loadLocale)(projectDir, set, sourceLocale)).messages;
+        const srcOld = (await (0, locale_files_1.loadLocale)(projectDir, set, sourceLocale, readOld)).messages;
+        const source = diffKeys(srcNow, srcOld);
+        const locales = [];
+        const targets = Object.keys(set.files)
+            .filter((l) => l !== sourceLocale && (!options.locales?.length || options.locales.includes(l)))
+            .sort();
+        for (const locale of targets) {
+            const nowLoaded = await (0, locale_files_1.loadLocale)(projectDir, set, locale);
+            const tgtNow = nowLoaded.messages;
+            const tgtOld = (await (0, locale_files_1.loadLocale)(projectDir, set, locale, readOld)).messages;
+            const fileDeleted = set.files[locale].every((f) => changed.has(f)) && Object.keys(tgtNow).length === 0 && nowLoaded.errors.length === 0 && Object.keys(tgtOld).length > 0;
+            const changedTarget = Object.keys(tgtNow).filter((k) => tgtNow[k] !== tgtOld[k]);
+            // Deleted translations whose source key still exists.
+            const removedTarget = Object.keys(tgtOld).filter((k) => !(k in tgtNow) && k in srcNow);
+            const removed = new Set(removedTarget);
+            const keys = fileDeleted
+                ? new Set(Object.keys(srcNow))
+                : new Set([...changedTarget, ...source.added, ...source.changed, ...source.removed.filter((k) => k in tgtNow)].filter((k) => !removed.has(k)));
+            if (keys.size === 0 && removedTarget.length === 0)
+                continue;
+            const report = (0, locale_qa_1.checkLocalePair)(srcNow, tgtNow, locale, { sourceLocale, glossary, keys: [...keys] });
+            if (fileDeleted) {
+                report.issues.unshift({
+                    locale,
+                    key: '*',
+                    code: 'translation_removed',
+                    severity: 'error',
+                    message: `The ${locale} locale file was deleted: all ${Object.keys(srcNow).length} source keys are now missing in ${locale}.`,
+                });
+            }
+            else {
+                for (const key of removedTarget) {
+                    report.issues.push({
+                        locale,
+                        key,
+                        code: 'translation_removed',
+                        severity: 'error',
+                        message: `Translation "${clip(tgtOld[key])}" was deleted but the source still has this key; the app falls back to the source text.`,
+                    });
+                }
+            }
+            for (const key of source.changed) {
+                if (tgtNow[key] !== undefined && tgtNow[key] === tgtOld[key]) {
+                    report.issues.push({
+                        locale,
+                        key,
+                        code: 'stale_translation',
+                        severity: 'warning',
+                        message: `Source changed from "${clip(srcOld[key])}" to "${clip(srcNow[key])}" but this translation wasn't updated.`,
+                    });
+                }
+            }
+            locales.push({ ...(0, locale_qa_1.tallyLocaleIssues)(report), changedKeys: changedTarget.length, removedKeys: removedTarget.length, fileDeleted });
+        }
+        reviews.push({ dir: set.dir, layout: set.layout, sourceLocale, source, locales });
+    }
+    const changedLocaleFiles = [...changed].filter((f) => localeFiles.has(f)).sort();
+    return {
+        base: label,
+        changedLocaleFiles,
+        changedOtherFiles: changed.size - changedLocaleFiles.length,
+        sets: reviews,
+    };
+}

package/dist/runtime/config.d.ts

@@ -0,0 +1,8 @@
+import type { EngineConfigV2 } from './types';
+/**
+ * Runtime config validation for the backend engine (v2).
+ *
+ * This mirrors the existing backend contract used by workers/controllers.
+ * (A separate Zod schema exists for the internal v2 modules.)
+ */
+export declare function validateEngineConfigV2(config: Partial<EngineConfigV2>): EngineConfigV2;

package/dist/runtime/config.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEngineConfigV2 = validateEngineConfigV2;
+/**
+ * Runtime config validation for the backend engine (v2).
+ *
+ * This mirrors the existing backend contract used by workers/controllers.
+ * (A separate Zod schema exists for the internal v2 modules.)
+ */
+function validateEngineConfigV2(config) {
+    if (!config.workspacePath) {
+        throw new Error('workspacePath is required');
+    }
+    const confidenceThreshold = config.confidenceThreshold ?? 80;
+    if (confidenceThreshold < 0 || confidenceThreshold > 100) {
+        throw new Error(`confidenceThreshold must be between 0 and 100, got ${confidenceThreshold}`);
+    }
+    return {
+        workspacePath: config.workspacePath,
+        inputType: config.inputType || 'github',
+        sourceLocale: config.sourceLocale || 'en',
+        targetLocales: config.targetLocales || [],
+        framework: config.framework,
+        confidenceThreshold,
+        dryRun: config.dryRun ?? false,
+        forceTranslation: config.forceTranslation ?? false,
+        onProgress: config.onProgress,
+        projectId: config.projectId,
+        filesToProcess: config.filesToProcess,
+        byok: config.byok,
+        providers: config.providers,
+        formatConfig: config.formatConfig,
+        staticRuntime: config.staticRuntime,
+        installDependencies: config.installDependencies,
+    };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export type { EngineConfigV2, EngineResultV2 } from './types';
+export { validateEngineConfigV2 } from './config';
+export { runEngineV2 } from '../orchestrator';

package/dist/runtime/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEngineV2 = exports.validateEngineConfigV2 = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "validateEngineConfigV2", { enumerable: true, get: function () { return config_1.validateEngineConfigV2; } });
+// `runEngineV2` is implemented in `../orchestrator` as the single wiring point.
+var orchestrator_1 = require("../orchestrator");
+Object.defineProperty(exports, "runEngineV2", { enumerable: true, get: function () { return orchestrator_1.runEngineV2; } });