@babelize/engine 0.0.0-stage → 0.1.0

package/dist/utils/translator-load-balancer.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * Translator Load Balancer
+ *
+ * Manages multiple translator endpoints with:
+ * - Health checking
+ * - Round-robin load balancing
+ * - Automatic failover on errors
+ * - Circuit breaker per endpoint
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translatorLoadBalancer = void 0;
+exports.getTranslatorLoadBalancer = getTranslatorLoadBalancer;
+const circuit_breaker_1 = require("./circuit-breaker");
+const logger_1 = require("./logger");
+const DEFAULT_CONFIG = {
+    endpoints: [],
+    healthCheckInterval: 60000, // 1 minute
+    healthCheckTimeout: 10000, // 10 seconds
+    maxConsecutiveFailures: 3,
+};
+class TranslatorLoadBalancer {
+    constructor() {
+        this.circuitBreakers = new Map();
+        this.healthCheckInterval = null;
+        this.currentEndpointIndex = 0;
+        this.config = { ...DEFAULT_CONFIG };
+        this.initializeEndpoints();
+        if (this.config.endpoints.length > 0) {
+            setTimeout(() => this.startHealthChecks(), 0);
+        }
+    }
+    /**
+     * Initialize endpoints from environment variable
+     * Format: url1|name1,url2|name2 or just url1,url2
+     */
+    initializeEndpoints() {
+        const translatorUrl = process.env.TRANSLATOR_URL;
+        const backupUrl = process.env.TRANSLATOR_BACKUP_URL;
+        const endpoints = [];
+        // Primary endpoint
+        if (translatorUrl) {
+            endpoints.push({
+                url: translatorUrl,
+                name: 'primary',
+                priority: 1,
+                isHealthy: true,
+                lastHealthCheck: null,
+                consecutiveFailures: 0,
+            });
+        }
+        // Backup endpoint
+        if (backupUrl) {
+            endpoints.push({
+                url: backupUrl,
+                name: 'backup',
+                priority: 2,
+                isHealthy: true,
+                lastHealthCheck: null,
+                consecutiveFailures: 0,
+            });
+        }
+        // Parse additional endpoints from TRANSLATOR_ENDPOINTS env var
+        // Format: url1|name1,url2|name2
+        const additionalEndpoints = process.env.TRANSLATOR_ENDPOINTS;
+        if (additionalEndpoints) {
+            additionalEndpoints.split(',').forEach((entry, index) => {
+                const [url, name] = entry.trim().split('|');
+                if (url) {
+                    endpoints.push({
+                        url: url.trim(),
+                        name: name?.trim() || `endpoint-${index + 3}`,
+                        priority: index + 3,
+                        isHealthy: true,
+                        lastHealthCheck: null,
+                        consecutiveFailures: 0,
+                    });
+                }
+            });
+        }
+        this.config.endpoints = endpoints;
+        // Create circuit breaker for each endpoint
+        endpoints.forEach(endpoint => {
+            this.circuitBreakers.set(endpoint.name, (0, circuit_breaker_1.getCircuitBreaker)(`translator-${endpoint.name}`, {
+                failureThreshold: 5,
+                resetTimeout: 30000,
+                halfOpenMaxCalls: 3,
+            }));
+        });
+        logger_1.engineLogger.info('Translator load balancer initialized', {
+            endpointCount: endpoints.length,
+            endpoints: endpoints.map(e => ({ name: e.name, url: e.url.substring(0, 50) })),
+        });
+    }
+    /**
+     * Get the next healthy endpoint using weighted round-robin
+     */
+    getNextEndpoint() {
+        const healthyEndpoints = this.config.endpoints
+            .filter(e => e.isHealthy)
+            .sort((a, b) => a.priority - b.priority);
+        if (healthyEndpoints.length === 0) {
+            // All endpoints unhealthy, try primary anyway
+            if (this.config.endpoints.length > 0) {
+                logger_1.engineLogger.warn('All translator endpoints unhealthy, attempting primary');
+                return this.config.endpoints[0];
+            }
+            return null;
+        }
+        // Round-robin among healthy endpoints
+        const endpoint = healthyEndpoints[this.currentEndpointIndex % healthyEndpoints.length];
+        this.currentEndpointIndex++;
+        return endpoint;
+    }
+    /**
+     * Mark an endpoint as failed
+     */
+    markEndpointFailed(endpoint) {
+        endpoint.consecutiveFailures++;
+        if (endpoint.consecutiveFailures >= this.config.maxConsecutiveFailures) {
+            endpoint.isHealthy = false;
+            logger_1.engineLogger.warn('Translator endpoint marked unhealthy', {
+                name: endpoint.name,
+                failures: endpoint.consecutiveFailures,
+            });
+        }
+    }
+    /**
+     * Mark an endpoint as successful
+     */
+    markEndpointSuccess(endpoint) {
+        if (!endpoint.isHealthy || endpoint.consecutiveFailures > 0) {
+            logger_1.engineLogger.info('Translator endpoint recovered', { name: endpoint.name });
+        }
+        endpoint.consecutiveFailures = 0;
+        endpoint.isHealthy = true;
+    }
+    /**
+     * Execute a translation request with automatic failover and exponential backoff
+     */
+    async executeWithFailover(requestFn) {
+        const maxAttempts = parseInt(process.env.TRANSLATOR_RETRY_ATTEMPTS || '2');
+        const triedEndpoints = [];
+        let lastError = null;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const endpoint = this.getNextEndpoint();
+            if (!endpoint) {
+                // No endpoints available
+                break;
+            }
+            if (triedEndpoints.includes(endpoint.name)) {
+                // If we've already tried this endpoint, allow retry only when
+                // it's the only endpoint available (otherwise cycle to next)
+                const healthyEndpoints = this.config.endpoints.filter(e => e.isHealthy);
+                if (healthyEndpoints.length > 1) {
+                    continue; // Skip to next round-robin pick
+                }
+                // Single endpoint — retrying it is our only option
+            }
+            if (!triedEndpoints.includes(endpoint.name)) {
+                triedEndpoints.push(endpoint.name);
+            }
+            const circuitBreaker = this.circuitBreakers.get(endpoint.name);
+            try {
+                const result = await (circuitBreaker
+                    ? circuitBreaker.execute(() => requestFn(endpoint.url))
+                    : requestFn(endpoint.url));
+                this.markEndpointSuccess(endpoint);
+                return result;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                this.markEndpointFailed(endpoint);
+                logger_1.engineLogger.warn('Translator endpoint failed, trying fallback', {
+                    endpoint: endpoint.name,
+                    error: lastError.message,
+                    attempt: attempt + 1,
+                    maxAttempts,
+                });
+                // Exponential backoff with jitter before next attempt
+                // Only delay if we have more attempts remaining
+                if (attempt < maxAttempts - 1) {
+                    const baseDelay = Math.min(200 * Math.pow(2, attempt), 3000); // Max 3s
+                    const jitter = Math.random() * 200; // 0-200ms jitter
+                    const delay = baseDelay + jitter;
+                    logger_1.engineLogger.info('Waiting before retry', {
+                        delayMs: Math.round(delay),
+                        nextAttempt: attempt + 2
+                    });
+                    await this.sleep(delay);
+                }
+            }
+        }
+        const endpointsTried = triedEndpoints.length > 0
+            ? `tried endpoints: [${triedEndpoints.join(', ')}]`
+            : 'no endpoints available';
+        throw lastError
+            ? new Error(`Translator request failed after ${maxAttempts} attempts (${endpointsTried}): ${lastError.message}`)
+            : new Error(`All translator endpoints failed (${endpointsTried})`);
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Perform health check on all endpoints
+     */
+    async healthCheck() {
+        const results = {};
+        for (const endpoint of this.config.endpoints) {
+            let timeout;
+            try {
+                const controller = new AbortController();
+                timeout = setTimeout(() => controller.abort(), this.config.healthCheckTimeout);
+                const response = await fetch(`${endpoint.url}/health`, {
+                    method: 'GET',
+                    signal: controller.signal,
+                });
+                const isHealthy = response.ok;
+                endpoint.isHealthy = isHealthy;
+                endpoint.lastHealthCheck = new Date();
+                if (isHealthy) {
+                    endpoint.consecutiveFailures = 0;
+                    // Reset the circuit breaker so subsequent calls don't fail immediately
+                    const cb = this.circuitBreakers.get(endpoint.name);
+                    if (cb) {
+                        cb.reset();
+                        logger_1.engineLogger.info('Circuit breaker reset after healthy health check', { endpoint: endpoint.name });
+                    }
+                }
+                results[endpoint.name] = isHealthy;
+            }
+            catch {
+                endpoint.isHealthy = false;
+                endpoint.lastHealthCheck = new Date();
+                results[endpoint.name] = false;
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+        return results;
+    }
+    /**
+     * Start periodic health checks
+     */
+    startHealthChecks() {
+        if (this.healthCheckInterval)
+            return;
+        this.healthCheckInterval = setInterval(() => this.healthCheck(), this.config.healthCheckInterval);
+        // Initial health check
+        this.healthCheck();
+    }
+    /**
+     * Stop periodic health checks
+     */
+    stopHealthChecks() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+    }
+    /**
+     * Get current status of all endpoints
+     */
+    getStatus() {
+        return this.config.endpoints.map(e => ({
+            name: e.name,
+            url: e.url.substring(0, 50) + (e.url.length > 50 ? '...' : ''),
+            isHealthy: e.isHealthy,
+            failures: e.consecutiveFailures,
+        }));
+    }
+}
+// Singleton instance
+// Created on first use, not at import: the constructor reads TRANSLATOR_*
+// env vars and starts health checks, and importing @babelize/engine must not
+// do either — a host may load its env (dotenv, test setup) after the import.
+let instance = null;
+function getTranslatorLoadBalancer() {
+    if (!instance)
+        instance = new TranslatorLoadBalancer();
+    return instance;
+}
+exports.translatorLoadBalancer = new Proxy({}, {
+    get(_target, prop) {
+        const lb = getTranslatorLoadBalancer();
+        const value = Reflect.get(lb, prop, lb);
+        return typeof value === 'function' ? value.bind(lb) : value;
+    },
+});

package/dist/utils/ui-copy.d.ts

@@ -0,0 +1,32 @@
+import * as t from '@babel/types';
+/**
+ * UI copy vs program data in object / array / variable initializers.
+ *
+ * `const user = { name: "Ada" }` is data: translating it rewrites a user's
+ * name (`{ name: t("page.ada") }`). `[{ label: "Home", href: "/" }]` holds UI
+ * copy under `label` and data under `href`. A string in an initializer is
+ * only extracted when its key says it's copy, or (without a telling key) when
+ * it looks like copy: a sentence, a Title Case phrase or a capitalized word.
+ * Both lists match the key's last camelCase word (`buttonLabel` → label,
+ * `firstName` → name) or the whole key, case-insensitively, and can be
+ * extended by callers.
+ */
+export declare const UI_COPY_KEYS: Set<string>;
+export declare const DATA_KEYS: Set<string>;
+/** Two or more words with letters: reads like copy, not an identifier. */
+export declare function isMultiWordCopy(text: string): boolean;
+/**
+ * Copy without a key to say so: a sentence or Title Case phrase, or a single
+ * capitalized word ("Overview", "Settings"). Data looks different: lowercase
+ * tokens ("active"), kebab/snake/camelCase, ALLCAPS, or anything with digits,
+ * underscores, slashes or dots in a single token.
+ */
+export declare function looksLikeCopy(text: string): boolean;
+/** Whether a string stored under `name` (a key or a variable) is UI copy. */
+export declare function isUiCopyForName(name: string | null, text: string): boolean;
+/**
+ * For a string literal in an object property value, array element or
+ * variable/assignment initializer: is it UI copy? Other positions (JSX,
+ * returns, conditionals, …) aren't initializers and are left as they are.
+ */
+export declare function isUiCopyLiteral(node: t.Node, parent: t.Node | null | undefined, text: string): boolean;

package/dist/utils/ui-copy.js

@@ -0,0 +1,126 @@
+"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.DATA_KEYS = exports.UI_COPY_KEYS = void 0;
+exports.isMultiWordCopy = isMultiWordCopy;
+exports.looksLikeCopy = looksLikeCopy;
+exports.isUiCopyForName = isUiCopyForName;
+exports.isUiCopyLiteral = isUiCopyLiteral;
+const t = __importStar(require("@babel/types"));
+/**
+ * UI copy vs program data in object / array / variable initializers.
+ *
+ * `const user = { name: "Ada" }` is data: translating it rewrites a user's
+ * name (`{ name: t("page.ada") }`). `[{ label: "Home", href: "/" }]` holds UI
+ * copy under `label` and data under `href`. A string in an initializer is
+ * only extracted when its key says it's copy, or (without a telling key) when
+ * it looks like copy: a sentence, a Title Case phrase or a capitalized word.
+ * Both lists match the key's last camelCase word (`buttonLabel` → label,
+ * `firstName` → name) or the whole key, case-insensitively, and can be
+ * extended by callers.
+ */
+exports.UI_COPY_KEYS = new Set([
+    'label', 'title', 'description', 'placeholder', 'text', 'message', 'heading', 'subheading', 'headline', 'subtitle',
+    'tooltip', 'cta', 'alt', 'arialabel', 'caption', 'hint', 'help', 'helptext', 'summary', 'body', 'question',
+    'answer', 'notice', 'error', 'success', 'warning', 'confirm', 'prompt', 'greeting', 'tagline', 'blurb', 'excerpt',
+]);
+exports.DATA_KEYS = new Set([
+    'name', 'id', 'key', 'email', 'username', 'slug', 'url', 'href', 'src', 'path', 'type', 'value', 'code', 'locale',
+    'lang', 'language', 'classname', 'class', 'variant', 'color', 'colour', 'icon', 'date', 'currency', 'size', 'status',
+    'role', 'method', 'format', 'mode', 'theme', 'target', 'rel', 'route', 'to', 'link', 'ref', 'uuid', 'token',
+    'phone', 'address', 'image', 'avatar', 'file', 'filename', 'extension', 'mime', 'kind', 'timezone', 'country',
+    'handle', 'domain', 'host', 'endpoint', 'version', 'sku', 'hash', 'secret', 'password', 'field', 'event', 'action',
+    'user', 'author', 'owner', 'customer', 'company', 'brand', 'city', 'state', 'zip', 'region',
+]);
+function words(name) {
+    return name.split(/(?=[A-Z])|[-_\s]/).filter(Boolean).map((w) => w.toLowerCase());
+}
+/** Two or more words with letters: reads like copy, not an identifier. */
+function isMultiWordCopy(text) {
+    return text.trim().split(/\s+/).filter((w) => /\p{L}/u.test(w)).length >= 2;
+}
+/**
+ * Copy without a key to say so: a sentence or Title Case phrase, or a single
+ * capitalized word ("Overview", "Settings"). Data looks different: lowercase
+ * tokens ("active"), kebab/snake/camelCase, ALLCAPS, or anything with digits,
+ * underscores, slashes or dots in a single token.
+ */
+function looksLikeCopy(text) {
+    const trimmed = text.trim();
+    if (isMultiWordCopy(trimmed))
+        return true;
+    return /^\p{Lu}\p{Ll}+[!?.:…]?$/u.test(trimmed);
+}
+/** Whether a string stored under `name` (a key or a variable) is UI copy. */
+function isUiCopyForName(name, text) {
+    if (name) {
+        const parts = words(name);
+        const last = parts[parts.length - 1] ?? '';
+        const full = name.toLowerCase().replace(/[-_]/g, '');
+        if (exports.UI_COPY_KEYS.has(last) || exports.UI_COPY_KEYS.has(full))
+            return true;
+        if (exports.DATA_KEYS.has(last) || exports.DATA_KEYS.has(full))
+            return false;
+    }
+    return looksLikeCopy(text);
+}
+function keyName(key) {
+    if (t.isIdentifier(key))
+        return key.name;
+    if (t.isStringLiteral(key))
+        return key.value;
+    return null;
+}
+/**
+ * For a string literal in an object property value, array element or
+ * variable/assignment initializer: is it UI copy? Other positions (JSX,
+ * returns, conditionals, …) aren't initializers and are left as they are.
+ */
+function isUiCopyLiteral(node, parent, text) {
+    if (!parent)
+        return true;
+    if (t.isObjectProperty(parent) && parent.value === node)
+        return isUiCopyForName(parent.computed ? null : keyName(parent.key), text);
+    if (t.isVariableDeclarator(parent) && parent.init === node)
+        return isUiCopyForName(t.isIdentifier(parent.id) ? parent.id.name : null, text);
+    if (t.isAssignmentExpression(parent) && parent.right === node) {
+        const left = parent.left;
+        const name = t.isIdentifier(left) ? left.name : t.isMemberExpression(left) && !left.computed && t.isIdentifier(left.property) ? left.property.name : null;
+        return isUiCopyForName(name, text);
+    }
+    if (t.isArrayExpression(parent))
+        return looksLikeCopy(text);
+    return true;
+}

package/dist/utils/workspace.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Remove stale locale files from the workspace that are NOT in the target locale list.
+ *
+ * When a project is re-run with changed languages, old locale files from previous
+ * runs persist because `git reset --hard` only resets tracked files and generated
+ * locale files are untracked. This function cleans them up.
+ *
+ * @param workspacePath - Path to the workspace directory
+ * @param targetLocales - Current list of target locale codes (e.g., ['fr', 'de'])
+ * @param sourceLocale - Source locale code (e.g., 'en') — always preserved
+ * @param localeFormat - Output format ('json' | 'po' | 'arb')
+ * @param publicDir - Public directory relative to workspace (e.g., 'public')
+ */
+export declare function removeStaleLocales(workspacePath: string, targetLocales: string[], sourceLocale: string, localeFormat?: string, publicDir?: string): Promise<void>;

package/dist/utils/workspace.js

@@ -0,0 +1,89 @@
+"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.removeStaleLocales = removeStaleLocales;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const file_utils_1 = require("./file-utils");
+const logger_1 = require("./logger");
+/**
+ * Remove stale locale files from the workspace that are NOT in the target locale list.
+ *
+ * When a project is re-run with changed languages, old locale files from previous
+ * runs persist because `git reset --hard` only resets tracked files and generated
+ * locale files are untracked. This function cleans them up.
+ *
+ * @param workspacePath - Path to the workspace directory
+ * @param targetLocales - Current list of target locale codes (e.g., ['fr', 'de'])
+ * @param sourceLocale - Source locale code (e.g., 'en') — always preserved
+ * @param localeFormat - Output format ('json' | 'po' | 'arb')
+ * @param publicDir - Public directory relative to workspace (e.g., 'public')
+ */
+async function removeStaleLocales(workspacePath, targetLocales, sourceLocale, localeFormat = 'json', publicDir = 'public') {
+    // Django uses locale/<lang>/LC_MESSAGES/ — skip stale locale removal for PO format
+    if (localeFormat === 'po')
+        return;
+    const localesDir = path.join(workspacePath, publicDir, 'locales');
+    if (!(await fs.pathExists(localesDir))) {
+        return;
+    }
+    const ext = (0, file_utils_1.localeExtension)(localeFormat);
+    const allowedLocales = new Set([sourceLocale, ...targetLocales]);
+    try {
+        const entries = await fs.readdir(localesDir);
+        let removedCount = 0;
+        for (const entry of entries) {
+            if (!entry.endsWith(ext))
+                continue;
+            const localeCode = entry.replace(ext, '');
+            if (!allowedLocales.has(localeCode)) {
+                const filePath = path.join(localesDir, entry);
+                await fs.remove(filePath);
+                removedCount++;
+                logger_1.engineLogger.debug('Removed stale locale file', { file: entry, localeCode });
+            }
+        }
+        if (removedCount > 0) {
+            logger_1.engineLogger.info('Cleaned up stale locale files', {
+                removedCount,
+                keptLocales: [...allowedLocales],
+                workspacePath,
+            });
+        }
+    }
+    catch (err) {
+        logger_1.engineLogger.warn('Failed to clean up stale locale files', { error: err, workspacePath });
+    }
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@babelize/engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Babelize translation pipeline (extract, keygen, translate, inject). Infrastructure is injected through provider/store interfaces.",
+  "keywords": [
+    "babelize",
+    "i18n",
+    "localization",
+    "translation",
+    "ast"
+  ],
+  "license": "Apache-2.0",
+  "homepage": "https://babelize.co",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/babelize/babelize-dashboard.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "schemas"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "test": "jest",
+    "prepublishOnly": "npm run build && npm test && npm run typecheck"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.28.5",
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5",
+    "@babel/types": "^7.29.8",
+    "@babelize/types": "^0.1.1",
+    "@vue/compiler-dom": "^3.5",
+    "@vue/compiler-sfc": "^3.5",
+    "diff": "^8.0.4",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.3",
+    "gettext-parser": "^9.1.1",
+    "magic-string": "^0.30",
+    "node-html-parser": "^8.0.4",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@jest/globals": "^30.3.0",
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__traverse": "^7.28.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.3",
+    "ajv": "^8.17.1",
+    "eslint": "^9.39.2",
+    "intl-messageformat": "^10.7.16",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.1"
+  }
+}