@babelize/engine 0.0.0-stage → 0.1.2

package/dist/utils/module-constants.js

@@ -0,0 +1,265 @@
+"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.analyzeModuleConstants = analyzeModuleConstants;
+const t = __importStar(require("@babel/types"));
+const types_1 = require("../runtime/types");
+const ast_helpers_1 = require("./ast-helpers");
+const string_utils_1 = require("./string-utils");
+const jsx_message_1 = require("./jsx-message");
+const ui_copy_1 = require("./ui-copy");
+const attr = (el, name) => el.openingElement.attributes.some((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name }));
+function positionOf(expr) {
+    const container = expr.parentPath;
+    if (!container?.isJSXExpressionContainer() || container.node.expression !== expr.node)
+        return 'other';
+    const holder = container.parentPath;
+    if (holder?.isJSXElement()) {
+        const tag = holder.node.openingElement.name;
+        // Form data, not display text: <option>{x}</option> without a value is
+        // the submitted value; <textarea>{x}</textarea> is the field's content.
+        if (t.isJSXIdentifier(tag, { name: 'option' }) && !attr(holder.node, 'value'))
+            return 'form';
+        if (t.isJSXIdentifier(tag, { name: 'textarea' }))
+            return 'form';
+        return 'render';
+    }
+    if (holder?.isJSXFragment())
+        return 'render';
+    if (holder?.isJSXAttribute() && t.isJSXIdentifier(holder.node.name)) {
+        if (holder.node.name.name === 'key')
+            return 'identity';
+        if (types_1.JSX_TRANSLATABLE_ATTRS.includes(holder.node.name.name))
+            return 'render';
+    }
+    return 'other';
+}
+const inComponent = (p) => (0, ast_helpers_1.isInsideComponent)(p) && !!(0, ast_helpers_1.findComponentBody)(p);
+/** The render site is part of a JSX sentence (one message): the sentence pass owns it. */
+function inSentence(p) {
+    let el = p.parentPath;
+    while (el && (el.isJSXExpressionContainer() || el.isJSXElement() || el.isJSXFragment())) {
+        if ((el.isJSXElement() || el.isJSXFragment()) && (0, jsx_message_1.buildJsxMessage)(el.node).kind === 'message')
+            return true;
+        el = el.parentPath;
+    }
+    return false;
+}
+function memberName(p) {
+    if (!p.isMemberExpression() || p.node.computed || !t.isIdentifier(p.node.property))
+        return null;
+    return p.node.property.name;
+}
+/** Plans for a file's module-level UI constants that are rendered in components. */
+function analyzeModuleConstants(ast) {
+    const plans = [];
+    (0, ast_helpers_1.traverse)(ast, {
+        Program(program) {
+            for (const stmt of program.get('body')) {
+                const exported = stmt.isExportNamedDeclaration();
+                const decl = exported ? stmt.get('declaration') : stmt;
+                if (!decl?.isVariableDeclaration() || decl.node.kind !== 'const')
+                    continue;
+                for (const d of decl.get('declarations')) {
+                    const plan = planFor(d, exported);
+                    if (plan)
+                        plans.push(plan);
+                }
+            }
+            program.stop();
+        },
+    });
+    return plans;
+}
+function planFor(d, exported) {
+    if (!t.isIdentifier(d.node.id))
+        return null;
+    const name = d.node.id.name;
+    const init = d.get('init');
+    const isCopy = (s) => (0, string_utils_1.isTranslatableText)(s.trim());
+    // Per "field" ('' for an array of strings): the UI-copy literals that would
+    // become keys, every translatable literal (reported if not provable), and
+    // whether every value of the field is such a literal. A render site may
+    // only be wrapped in t() if all its values become keys — `["Overview",
+    // "FAQ"]` with only "Overview" keyed would render a missing key for FAQ.
+    const byField = new Map();
+    const translatable = new Map();
+    const incomplete = new Set();
+    const push = (map, field, lit) => map.set(field, [...(map.get(field) ?? []), lit]);
+    const consider = (field, value, uiCopy) => {
+        if (!value.isStringLiteral()) {
+            incomplete.add(field);
+            return;
+        }
+        if (isCopy(value.node.value))
+            push(translatable, field, value);
+        if (isCopy(value.node.value) && uiCopy(value.node.value))
+            push(byField, field, value);
+        else
+            incomplete.add(field);
+    };
+    let kind;
+    const objectFields = (objects) => {
+        const fields = new Set();
+        for (const obj of objects) {
+            for (const prop of obj.get('properties')) {
+                if (prop.isObjectProperty() && !prop.node.computed && t.isIdentifier(prop.node.key))
+                    fields.add(prop.node.key.name);
+            }
+        }
+        for (const obj of objects) {
+            const props = new Map();
+            let opaque = false;
+            for (const prop of obj.get('properties')) {
+                if (prop.isObjectProperty() && !prop.node.computed && t.isIdentifier(prop.node.key))
+                    props.set(prop.node.key.name, prop.get('value'));
+                else
+                    opaque = true; // spread / computed keys: any field may come from there
+            }
+            for (const field of fields) {
+                const value = props.get(field);
+                if (!value || opaque)
+                    incomplete.add(field);
+                if (value)
+                    consider(field, value, (text) => (0, ui_copy_1.isUiCopyForName)(field, text));
+            }
+        }
+    };
+    if (init.isArrayExpression()) {
+        const elements = init.get('elements');
+        if (elements.length > 0 && elements.every((e) => e.isStringLiteral())) {
+            kind = 'strings';
+            for (const e of elements)
+                consider('', e, ui_copy_1.looksLikeCopy);
+        }
+        else if (elements.length > 0 && elements.every((e) => e.isObjectExpression())) {
+            kind = 'objects';
+            objectFields(elements);
+        }
+        else {
+            return null;
+        }
+    }
+    else if (init.isObjectExpression()) {
+        kind = 'object';
+        objectFields([init]);
+    }
+    else {
+        return null;
+    }
+    if (translatable.size === 0)
+        return null;
+    const binding = d.scope.getBinding(name);
+    if (!binding)
+        return null;
+    const sites = new Map();
+    const fail = [];
+    const site = (field, expr) => {
+        if (!translatable.has(field))
+            return; // nothing translatable rendered from it
+        const pos = positionOf(expr);
+        if (pos === 'render') {
+            if (!inComponent(expr))
+                fail.push('rendered outside a component');
+            else if (inSentence(expr))
+                fail.push('rendered inside a sentence');
+            else if (incomplete.has(field))
+                fail.push('not every value is a translatable string');
+            sites.set(field, [...(sites.get(field) ?? []), expr]);
+        }
+        else if (pos === 'form') {
+            // Shown, but also the submitted value: report rather than rewrite.
+            fail.push(`${expr.toString()} is form data (<option> without a value, or <textarea>)`);
+            sites.set(field, [...(sites.get(field) ?? []), expr]);
+        }
+        else if (pos === 'other') {
+            fail.push(`${expr.toString()} is used as data`);
+        }
+    };
+    if (exported)
+        fail.push('exported');
+    if (binding.constantViolations.length)
+        fail.push('reassigned');
+    for (const ref of binding.referencePaths) {
+        const parent = ref.parentPath;
+        const prop = memberName(parent);
+        if ((kind === 'strings' || kind === 'objects') && prop === 'map' && parent.parentPath?.isCallExpression() && parent.parentPath.node.callee === parent.node) {
+            const cb = parent.parentPath.get('arguments')[0];
+            const param = cb && (cb.isArrowFunctionExpression() || cb.isFunctionExpression()) ? cb.node.params[0] : undefined;
+            if (!cb || !t.isIdentifier(param)) {
+                fail.push(`${name}.map callback doesn't take a plain parameter`);
+                continue;
+            }
+            const item = cb.scope.getBinding(param.name);
+            if (!item || item.constantViolations.length) {
+                fail.push(`${name}.map item is reassigned`);
+                continue;
+            }
+            for (const use of item.referencePaths) {
+                if (kind === 'strings') {
+                    site('', use);
+                    continue;
+                }
+                const member = use.parentPath;
+                const field = memberName(member);
+                if (field === null || !member.isMemberExpression() || member.node.object !== use.node) {
+                    fail.push(`${param.name} is used as a whole`);
+                }
+                else {
+                    site(field, member);
+                }
+            }
+            continue;
+        }
+        if (kind === 'object' && prop !== null) {
+            site(prop, parent);
+            continue;
+        }
+        if (kind === 'strings' && parent.isMemberExpression() && parent.node.computed && t.isNumericLiteral(parent.node.property)) {
+            // TABS[0]: only that element is rendered; keep it simple and treat as one field.
+            site('', parent);
+            continue;
+        }
+        fail.push(`${name} is used as data`);
+    }
+    if (sites.size === 0)
+        return null; // never rendered: it's data
+    const provable = fail.length === 0;
+    // Provable: the keyed literals (all values of each rendered field).
+    // Otherwise: every translatable literal that is rendered, to report.
+    const literals = [...sites.keys()].flatMap((f) => (provable ? byField : translatable).get(f) ?? []);
+    const renderSites = [...sites.values()].flat();
+    return { name, provable, literals, renderSites, reason: fail[0] };
+}

package/dist/utils/not-injected.d.ts

@@ -0,0 +1,6 @@
+import type { InjectionResult, KeyGenerationResult, NotInjectedString } from '../runtime/types';
+/**
+ * Keys generated this run whose string the injector didn't replace in its
+ * file. Their translations exist, but the app keeps showing the literal.
+ */
+export declare function findNotInjected(keyGeneration: KeyGenerationResult, injection: InjectionResult): NotInjectedString[];

package/dist/utils/not-injected.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNotInjected = findNotInjected;
+/**
+ * Keys generated this run whose string the injector didn't replace in its
+ * file. Their translations exist, but the app keeps showing the literal.
+ */
+function findNotInjected(keyGeneration, injection) {
+    const injected = new Set();
+    for (const file of injection.modifiedFiles) {
+        for (const i of file.injections)
+            injected.add(`${i.file ?? file.file}\u0000${i.key}`);
+    }
+    const skipped = new Map(injection.skippedFiles.map((f) => [f.file, f]));
+    const seen = new Set();
+    const out = [];
+    for (const k of keyGeneration.keys) {
+        if (k.isPlural)
+            continue; // the base key stands for its plural forms
+        if (k.gettext?.wrapped)
+            continue; // already marked in the code (gettext call / trans tag)
+        const file = k.extractionId.split(':')[0];
+        const id = `${file}\u0000${k.key}`;
+        if (injected.has(id) || seen.has(id))
+            continue;
+        seen.add(id);
+        const skip = skipped.get(file);
+        out.push({
+            file,
+            key: k.key,
+            text: k.value,
+            reason: skip
+                ? `file skipped (${skip.reason}${skip.details ? `: ${skip.details}` : ''})`
+                : 'no place to add the translation hook (e.g. outside a component, or a pattern the injector does not handle)',
+        });
+    }
+    return out;
+}

package/dist/utils/placeholder-protection.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Placeholder protection for machine translation.
+ *
+ * Everything in a UI string that must reach the translated output byte-for-byte
+ * — interpolation variables, markup tags, URLs, never-translate terms — is
+ * swapped for an opaque `[#VAR_n#]` token before translation, then validated
+ * and swapped back. The token format is shared with the Rust translator
+ * (apps/translator/src/placeholders.rs), so the same text works for every
+ * provider.
+ *
+ * ICU messages (`{count, plural, ...}`) are not tokenized: their structure has
+ * to change per locale (plural categories), so they are validated by
+ * ./icu-message instead.
+ */
+export interface ProtectedText {
+    /** Text to send to the translator, with protected spans replaced by tokens. */
+    text: string;
+    /** Original text of each token, by index: tokens[i] is what `[#VAR_i#]` stands for. */
+    tokens: string[];
+    /**
+     * What each token is restored to: the original text, except for a glossary
+     * "always translate as" term, which is restored to its fixed translation.
+     */
+    restore: string[];
+}
+/** A term protected as a token and restored to a fixed translation ("always translate as"). */
+export interface FixedTerm {
+    term: string;
+    translation: string;
+}
+export interface TokenCheck {
+    ok: boolean;
+    /** Indices whose token is absent from the translation. */
+    missing: number[];
+    /** Indices whose token appears more than once. */
+    duplicated: number[];
+    /** Token indices in the translation that were never issued. */
+    unexpected: number[];
+}
+/**
+ * Replace every protected span (and every never-translate term) with a token.
+ * With `icu: true`, braces are left alone (they are ICU structure) and only
+ * URLs, emails, code, tags and terms are tokenized.
+ * `fixedTerms` ("always translate as") are tokenized too, and `restore` maps
+ * their tokens to the fixed translation: a plain-text translator never sees
+ * the term, so it can't ignore the rule.
+ * Literal `[#VAR_n#]` text already present in the source is protected too, so
+ * it can never be confused with an issued token.
+ */
+export declare function protectText(text: string, neverTranslateTerms?: string[], options?: {
+    icu?: boolean;
+    fixedTerms?: FixedTerm[];
+}): ProtectedText;
+/** Every issued token must appear exactly once, and no other token may appear. */
+export declare function checkTokens(translated: string, tokenCount: number): TokenCheck;
+/**
+ * Swap tokens back. Pass protectText's `restore` (fixed glossary terms become
+ * their translation) or `tokens` (original text). Call only after checkTokens passed.
+ */
+export declare function restoreText(translated: string, tokens: string[]): string;
+/**
+ * True when nothing translatable is left once protected spans are removed —
+ * e.g. "{count}", "GitHub", "https://…", "%s / %s". Such strings are their
+ * own translation and should not be sent to a translator.
+ */
+export declare function hasNothingToTranslate(protectedText: string): boolean;
+/** Human-readable description of a failed token check, for retry prompts and reports. */
+export declare function describeTokenProblem(check: TokenCheck, tokens: string[]): string;
+/**
+ * Whether two strings contain the same protected spans (variables, tags,
+ * URLs, terms), ignoring order. Used to vet rewrites of an already-validated
+ * translation, e.g. a brand-voice polish pass.
+ */
+export declare function sameProtectedSpans(a: string, b: string, neverTranslateTerms?: string[]): boolean;

package/dist/utils/placeholder-protection.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * Placeholder protection for machine translation.
+ *
+ * Everything in a UI string that must reach the translated output byte-for-byte
+ * — interpolation variables, markup tags, URLs, never-translate terms — is
+ * swapped for an opaque `[#VAR_n#]` token before translation, then validated
+ * and swapped back. The token format is shared with the Rust translator
+ * (apps/translator/src/placeholders.rs), so the same text works for every
+ * provider.
+ *
+ * ICU messages (`{count, plural, ...}`) are not tokenized: their structure has
+ * to change per locale (plural categories), so they are validated by
+ * ./icu-message instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protectText = protectText;
+exports.checkTokens = checkTokens;
+exports.restoreText = restoreText;
+exports.hasNothingToTranslate = hasNothingToTranslate;
+exports.describeTokenProblem = describeTokenProblem;
+exports.sameProtectedSpans = sameProtectedSpans;
+const tokenFor = (index) => `[#VAR_${index}#]`;
+/** Matches a token, tolerating the spacing/casing drift LLMs introduce. */
+const TOKEN_PATTERN = /\[\s*#\s*VAR_(\d+)\s*#\s*\]/gi;
+/**
+ * What gets protected, in priority order (earlier alternatives win where
+ * matches overlap — e.g. a `{var}` inside a URL stays part of the URL).
+ */
+const PROTECTED_PATTERNS = [
+    { kind: 'url', source: String.raw `\b(?:https?|ftp|mailto):[^\s<>"'\])]+[^\s<>"'\]).,;:!?]` },
+    { kind: 'email', source: String.raw `\b[\w.+-]+@[\w-]+(?:\.[\w-]+)+\b` },
+    { kind: 'code', source: String.raw `\x60[^\x60\n]+\x60` },
+    // i18next / Handlebars / Mustache: {{name}}, {{- name}}, {{count, number}}
+    { kind: 'mustache', source: String.raw `\{\{[^{}]*\}\}` },
+    // JS template literal leftovers: ${name}
+    { kind: 'template', source: String.raw `\$\{[^{}]*\}` },
+    // i18next nesting: $t(key) / $t(key, {...})
+    { kind: 'nesting', source: String.raw `\$t\([^()]*\)` },
+    // Python named printf: %(name)s, %(count)d, %(price).2f
+    { kind: 'printf', source: String.raw `%\(\w+\)[-#0 +]*\d*(?:\.\d+)?[sdifr]` },
+    // Escaped percent in printf-style (gettext) strings: "50%% off"
+    { kind: 'printf', source: '%%' },
+    // printf: %s %d %1$s %.2f %@ — not "%" followed by a word ("50%done")
+    { kind: 'printf', source: String.raw `%(?:\d+\$)?[-+0#]*\d*(?:\.\d+)?[sdifu@xXc](?![A-Za-z])` },
+    // ICU simple / formatted args and positional args: {name} {0} {price, number} {d, date, short}
+    { kind: 'argument', source: String.raw `\{\s*[\w.]+\s*(?:,\s*(?:number|date|time)\s*(?:,\s*[^{}]+)?)?\}` },
+    // Python str.format positional field: "Only {} left"
+    { kind: 'argument', source: String.raw `\{\}` },
+    // HTML character references in markup-bearing text: &mdash; &nbsp; &#8217;
+    { kind: 'entity', source: String.raw `&(?:[a-zA-Z][a-zA-Z0-9]{1,31}|#\d{1,7}|#x[0-9a-fA-F]{1,6});` },
+    // Markup / react-i18next Trans tags: <0>, </0>, <1/>, <b>, </strong>, <br />, <Link href="...">
+    { kind: 'tag', source: String.raw `<\/?\d+\s*\/?>|<\/?[A-Za-z][\w.:-]*(?:\s+[^<>]*?)?\s*\/?>` },
+];
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** A term as a whole term in any script (same rule as modules/glossary termPattern). */
+function wholeTerm(term) {
+    return `(?<![\\p{L}\\p{N}_])${escapeRegex(term)}(?![\\p{L}\\p{N}_])`;
+}
+/** In ICU messages braces are structure, so only these kinds are tokenized. */
+const ICU_SAFE_KINDS = new Set(['url', 'email', 'code', 'tag', 'entity']);
+/**
+ * Placeholders, tags, URLs etc. come first, so a term never matches inside
+ * one ("{dashboard}", "https://\u2026/settings"). Terms match longest first; a
+ * never-translate term wins over a fixed term spelled the same (ignoring
+ * case). Fixed terms are the named groups `f<i>` (index into `fixed`).
+ */
+function buildPattern(neverTranslateTerms, icu, fixedTerms) {
+    const sources = PROTECTED_PATTERNS.filter((p) => !icu || ICU_SAFE_KINDS.has(p.kind)).map((p) => p.source);
+    const never = [...new Set(neverTranslateTerms.filter((t) => t.trim().length > 0))];
+    const neverLower = new Set(never.map((t) => t.toLowerCase()));
+    const seen = new Set();
+    const fixed = fixedTerms.filter((f) => {
+        const k = f.term.toLowerCase();
+        if (!f.term.trim() || !f.translation || neverLower.has(k) || seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+    const terms = [
+        ...never.map((t) => ({ term: t, source: wholeTerm(t) })),
+        ...fixed.map((f, i) => ({ term: f.term, source: `(?<f${i}>${wholeTerm(f.term)})` })),
+    ].sort((a, b) => b.term.length - a.term.length);
+    if (terms.length > 0)
+        sources.push(terms.map((t) => t.source).join('|'));
+    return { pattern: new RegExp(sources.map((s) => `(?:${s})`).join('|'), 'giu'), fixed };
+}
+/**
+ * Replace every protected span (and every never-translate term) with a token.
+ * With `icu: true`, braces are left alone (they are ICU structure) and only
+ * URLs, emails, code, tags and terms are tokenized.
+ * `fixedTerms` ("always translate as") are tokenized too, and `restore` maps
+ * their tokens to the fixed translation: a plain-text translator never sees
+ * the term, so it can't ignore the rule.
+ * Literal `[#VAR_n#]` text already present in the source is protected too, so
+ * it can never be confused with an issued token.
+ */
+function protectText(text, neverTranslateTerms = [], options = {}) {
+    const tokens = [];
+    const restore = [];
+    const { pattern, fixed } = buildPattern(neverTranslateTerms, options.icu ?? false, options.fixedTerms ?? []);
+    // Guard pre-existing token-shaped text first.
+    const guarded = text.replace(TOKEN_PATTERN, (m) => {
+        tokens.push(m);
+        restore.push(m);
+        return `\uE000${tokens.length - 1}\uE000`;
+    });
+    const protectedText = guarded
+        .replace(pattern, (...args) => {
+        const match = args[0];
+        const groups = args[args.length - 1];
+        let replacement = match;
+        if (fixed.length > 0 && groups && typeof groups === 'object') {
+            const g = groups;
+            const i = fixed.findIndex((_, idx) => g[`f${idx}`] !== undefined);
+            if (i >= 0)
+                replacement = fixed[i].translation;
+        }
+        tokens.push(match);
+        restore.push(replacement);
+        return tokenFor(tokens.length - 1);
+    })
+        .replace(/\uE000(\d+)\uE000/g, (_, i) => tokenFor(Number(i)));
+    return { text: protectedText, tokens, restore };
+}
+/** Every issued token must appear exactly once, and no other token may appear. */
+function checkTokens(translated, tokenCount) {
+    const counts = new Map();
+    for (const m of translated.matchAll(TOKEN_PATTERN)) {
+        const i = Number(m[1]);
+        counts.set(i, (counts.get(i) ?? 0) + 1);
+    }
+    const missing = [];
+    const duplicated = [];
+    for (let i = 0; i < tokenCount; i++) {
+        const c = counts.get(i) ?? 0;
+        if (c === 0)
+            missing.push(i);
+        else if (c > 1)
+            duplicated.push(i);
+    }
+    const unexpected = [...counts.keys()].filter((i) => i >= tokenCount);
+    return { ok: missing.length === 0 && duplicated.length === 0 && unexpected.length === 0, missing, duplicated, unexpected };
+}
+/**
+ * Swap tokens back. Pass protectText's `restore` (fixed glossary terms become
+ * their translation) or `tokens` (original text). Call only after checkTokens passed.
+ */
+function restoreText(translated, tokens) {
+    return translated.replace(TOKEN_PATTERN, (m, i) => tokens[Number(i)] ?? m);
+}
+/**
+ * True when nothing translatable is left once protected spans are removed —
+ * e.g. "{count}", "GitHub", "https://…", "%s / %s". Such strings are their
+ * own translation and should not be sent to a translator.
+ */
+function hasNothingToTranslate(protectedText) {
+    return !/\p{L}/u.test(protectedText.replace(TOKEN_PATTERN, ''));
+}
+/** Human-readable description of a failed token check, for retry prompts and reports. */
+function describeTokenProblem(check, tokens) {
+    const parts = [];
+    if (check.missing.length)
+        parts.push(`dropped ${check.missing.map((i) => `${tokenFor(i)} (${tokens[i]})`).join(', ')}`);
+    if (check.duplicated.length)
+        parts.push(`repeated ${check.duplicated.map(tokenFor).join(', ')}`);
+    if (check.unexpected.length)
+        parts.push(`invented ${check.unexpected.map(tokenFor).join(', ')}`);
+    return parts.join('; ');
+}
+/**
+ * Whether two strings contain the same protected spans (variables, tags,
+ * URLs, terms), ignoring order. Used to vet rewrites of an already-validated
+ * translation, e.g. a brand-voice polish pass.
+ */
+function sameProtectedSpans(a, b, neverTranslateTerms = []) {
+    const spans = (t) => protectText(t, neverTranslateTerms).tokens.slice().sort().join('\u0001');
+    return spans(a) === spans(b);
+}

package/dist/utils/pseudo-markers.d.ts

@@ -0,0 +1,9 @@
+/** Marks pseudo-localized text (`babelize translate --provider pseudo`); never part of a real translation. */
+export declare const PSEUDO_OPEN = "\u27E6";
+export declare const PSEUDO_CLOSE = "\u27E7";
+/**
+ * True for pseudo-localized output: text wrapped in ⟦…⟧ (whole value, or
+ * each branch of a plural the pseudo provider built). Accented letters alone
+ * are not a signal — "Sávé" could be real text in many languages.
+ */
+export declare function isPseudoLocalized(value: string): boolean;

package/dist/utils/pseudo-markers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PSEUDO_CLOSE = exports.PSEUDO_OPEN = void 0;
+exports.isPseudoLocalized = isPseudoLocalized;
+/** Marks pseudo-localized text (`babelize translate --provider pseudo`); never part of a real translation. */
+exports.PSEUDO_OPEN = '⟦';
+exports.PSEUDO_CLOSE = '⟧';
+/**
+ * True for pseudo-localized output: text wrapped in ⟦…⟧ (whole value, or
+ * each branch of a plural the pseudo provider built). Accented letters alone
+ * are not a signal — "Sávé" could be real text in many languages.
+ */
+function isPseudoLocalized(value) {
+    const open = value.indexOf(exports.PSEUDO_OPEN);
+    return open !== -1 && value.indexOf(exports.PSEUDO_CLOSE, open + 1) !== -1;
+}

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

@@ -0,0 +1,52 @@
+/**
+ * Engine v2 string utilities.
+ *
+ * Copied from v1 to preserve keygen/normalization behavior.
+ */
+export declare function normalizeString(text: string): string;
+export declare function toCamelCase(text: string): string;
+export declare function inferNamespace(filePath: string): string;
+export declare function generateUniqueKey(baseKey: string, existingKeys: Set<string>): string;
+export declare function truncateForKey(text: string, maxWords?: number): string;
+export declare function isTranslatableText(text: string): boolean;
+export declare function extractPlaceholders(text: string): string[];
+/**
+ * Protect placeholders by replacing them with AI-safe tokens before translation
+ */
+export declare function protectPlaceholders(text: string): {
+    protectedText: string;
+    vars: string[];
+};
+export interface RestorationResult {
+    restoredText: string;
+    restoredCount: number;
+    expectedCount: number;
+    missingTokens: string[];
+}
+/**
+ * Restore placeholders from AI-safe tokens after translation
+ * Returns a diagnostic result to detect dropped variables
+ */
+export declare function restorePlaceholders(text: string, vars: string[]): RestorationResult;
+/**
+ * Check if text text and associated variables likely represent a pluralized string
+ * (e.g. "count files", "Total {length}")
+ */
+export declare function isLikelyPlural(text: string, variables?: string[]): boolean;
+export declare function hasICUSyntax(text: string): boolean;
+export declare function escapeRegex(text: string): string;
+export declare function hashString(text: string): string;
+export declare function matchesCurrencyPattern(text: string): boolean;
+export declare function matchesDatePattern(text: string): boolean;
+export declare function containsPII(text: string): boolean;
+export declare const SKIP_TAGS: Set<string>;
+/**
+ * Extract content between balanced opening and closing tags, handling nested tags.
+ * Finds the first `<tagName>` and its matching `</tagName>`, correctly counting
+ * nested `<tagName ...>` elements.
+ */
+export declare function extractBalancedTag(content: string, tagName: string, allowAttrs?: boolean): {
+    fullMatch: string;
+    body: string;
+    attrs: string;
+} | null;