locai 2.3.0 → 2.5.0

package/dist/services/source-analyzer.js

@@ -0,0 +1,164 @@
+import { Project, Node } from "ts-morph";
+import { log } from "../utils/logger.js";
+import path from "path";
+export class SourceCodeAnalyzer {
+    project;
+    keyUsageMap = new Map();
+    rootDir;
+    initPromise = null;
+    constructor(rootDir = process.cwd()) {
+        this.rootDir = rootDir;
+        // Initialize with default settings, but don't add files yet for performance
+        this.project = new Project({
+            skipAddingFilesFromTsConfig: true,
+            compilerOptions: {
+                allowJs: true,
+                jsx: 1, // Preserve
+            },
+        });
+    }
+    initialize(globPatterns = [
+        "src/**/*.{ts,tsx}",
+        "app/**/*.{ts,tsx}",
+        "components/**/*.{ts,tsx}",
+    ]) {
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            await new Promise((resolve) => setTimeout(resolve, 0)); // Force async execution for race condition safety
+            try {
+                // Add source files
+                log(`Analyzing source code in ${this.rootDir}...`);
+                // Exclude node_modules explicitly just in case
+                this.project.addSourceFilesAtPaths(globPatterns);
+                const sourceFiles = this.project.getSourceFiles();
+                log(`Found ${sourceFiles.length} source files for context analysis.`);
+                for (const sourceFile of sourceFiles) {
+                    this.processFile(sourceFile);
+                }
+                log(`Source analysis complete. Context extracted for ${this.keyUsageMap.size} keys.`);
+            }
+            catch (error) {
+                console.warn(`Error during source analysis: ${error.message}`);
+                // Don't throw to prevent blocking the whole app, just log
+            }
+        })();
+        return this.initPromise;
+    }
+    async ensureInitialized() {
+        if (this.initPromise) {
+            await this.initPromise;
+        }
+    }
+    processFile(sourceFile) {
+        sourceFile.forEachDescendant((node) => {
+            if (Node.isCallExpression(node)) {
+                this.processCallExpression(node, sourceFile.getFilePath());
+            }
+        });
+    }
+    processCallExpression(node, filePath) {
+        // Match t('key') or useTranslations().t('key') pattern
+        // This is a heuristic match
+        const expression = node.getExpression();
+        // Check if expression is accessible
+        if (!expression)
+            return;
+        const expressionText = expression.getText();
+        // Simple check for 't' function calls
+        if (expressionText.endsWith(".t") || expressionText === "t") {
+            const args = node.getArguments();
+            if (args.length > 0 && Node.isStringLiteral(args[0])) {
+                const key = args[0].getLiteralText();
+                this.extractContext(key, node, filePath);
+            }
+        }
+    }
+    extractContext(key, node, fullFilePath) {
+        const relativePath = path.relative(this.rootDir, fullFilePath);
+        const line = node.getStartLineNumber();
+        // Extract component name
+        let componentName = undefined;
+        // Use getAncestors() to find the parent safely
+        const componentNode = node
+            .getAncestors()
+            .find((n) => Node.isFunctionDeclaration(n) ||
+            Node.isClassDeclaration(n) ||
+            Node.isVariableDeclaration(n));
+        if (componentNode) {
+            if (Node.isFunctionDeclaration(componentNode) ||
+                Node.isClassDeclaration(componentNode)) {
+                componentName = componentNode.getName();
+            }
+            else if (Node.isVariableDeclaration(componentNode)) {
+                componentName = componentNode.getName();
+            }
+        }
+        // Extract comments
+        // Look for leading comments on the statement
+        const statement = node
+            .getAncestors()
+            .find((n) => Node.isExpressionStatement(n) ||
+            Node.isVariableStatement(n) ||
+            Node.isJsxElement(n) ||
+            Node.isJsxExpression(n));
+        const comments = [];
+        const targetNode = statement || node;
+        const ranges = targetNode.getLeadingCommentRanges();
+        for (const range of ranges) {
+            comments.push(range
+                .getText()
+                .replace(/^\/\/\s*/, "")
+                .replace(/^\/\*\s*/, "")
+                .replace(/\s*\*\/$/, ""));
+        }
+        // Get props (simple heuristic for JSX)
+        const props = {};
+        const jsxElement = node
+            .getAncestors()
+            .find((n) => Node.isJsxOpeningElement(n) || Node.isJsxSelfClosingElement(n));
+        if (jsxElement &&
+            (Node.isJsxOpeningElement(jsxElement) || Node.isJsxSelfClosingElement(jsxElement))) {
+            jsxElement.getAttributes().forEach((attr) => {
+                if (Node.isJsxAttribute(attr)) {
+                    // Safe name extraction
+                    const nameNode = attr.getNameNode();
+                    const name = nameNode ? nameNode.getText() : "unknown";
+                    const initializer = attr.getInitializer();
+                    let value = initializer ? initializer.getText() : "true";
+                    // Strip quotes if string literal
+                    if ((value.startsWith('"') && value.endsWith('"')) ||
+                        (value.startsWith("'") && value.endsWith("'"))) {
+                        value = value.substring(1, value.length - 1);
+                    }
+                    props[name] = value;
+                }
+            });
+        }
+        // Code Snippet (surrounding lines)
+        // Check for node.getParent() to avoid error if node is root (unlikely for call expression)
+        const parent = node.getParent();
+        const snippet = parent ? parent.getText() : node.getText();
+        const context = {
+            filePath: relativePath,
+            line,
+            component: componentName,
+            usageSnippet: snippet.length > 200 ? snippet.substring(0, 200) + "..." : snippet,
+            comments: comments.length > 0 ? comments : undefined,
+            props: Object.keys(props).length > 0 ? props : undefined,
+        };
+        if (!this.keyUsageMap.has(key)) {
+            this.keyUsageMap.set(key, []);
+        }
+        this.keyUsageMap.get(key)?.push(context);
+    }
+    getContext(key) {
+        // Return duplicate functionality: prefer the first usage found or merge?
+        // For now return the first usage that has comments, or just the first usage.
+        const usages = this.keyUsageMap.get(key);
+        if (!usages || usages.length === 0)
+            return undefined;
+        // Prioritize usage with comments
+        return usages.find((u) => u.comments && u.comments.length > 0) || usages[0];
+    }
+}

package/dist/services/translation-service.d.ts

@@ -1,60 +1,12 @@
 import Orchestrator from "../core/orchestrator.js";
-import { OrchestratorOptions } from "../core/orchestrator.js";
 import StateManager from "../utils/state-manager.js";
-export interface TranslationOptions extends OrchestratorOptions {
-    source: string;
-    targets?: string[];
-    localesDir?: string;
-    debug?: boolean;
-    forceUpdate?: boolean;
-    syncOptions?: {
-        enabled?: boolean;
-        removeDeletedKeys?: boolean;
-    };
-    concurrencyLimit?: number;
-    saveReviewQueue?: boolean;
-    minConfidence?: number;
-    fileExtensions?: string[];
-}
-export interface GlobalStats {
-    total: number;
-    success: number;
-    failed: number;
-    skipped: number;
-    languages: Record<string, any>;
-    byCategory: Record<string, number>;
-    details: Record<string, {
-        totalConfidence: number;
-        samples: number;
-    }>;
-    error?: {
-        message: string;
-        time: string;
-        stack?: string;
-    };
-    orchestrators: any[];
-    endTime?: string;
-    totalDuration?: number;
-    totalTime: number;
-    startTime: string;
-}
-interface LanguageProcessResult {
-    status: any;
-    savedMessage?: string;
-    error?: string;
-}
+import { TranslationOptions, GlobalStats, LanguageProcessResult } from "../types/index.js";
 /**
  * Service for handling file translation operations.
  * Orchestrates the translation process including state management,
  * verification, and statistics collection.
  */
 declare class TranslationService {
-    /**
-     * Check if text only contains placeholders and whitespace.
-     * @param {string} text - Text to check.
-     * @returns {boolean} - True if text only contains placeholders.
-     */
-    isPlaceholderOnlyText(text: string): boolean;
     /**
      * Main translator function to process source file and create translations.
      * @param {string} file - Path to source file.

package/dist/services/translation-service.js

@@ -8,26 +8,14 @@ import InputValidator from "../utils/input-validator.js";
 import gracefulShutdown from "../utils/graceful-shutdown.js";
 import uiManager from "../utils/ui-manager.js";
 import statisticsManager from "../utils/statistics-manager.js";
+import { LanguageProcessor } from "./language-processor.js";
+import { SourceCodeAnalyzer } from "./source-analyzer.js";
 /**
  * Service for handling file translation operations.
  * Orchestrates the translation process including state management,
  * verification, and statistics collection.
  */
 class TranslationService {
-    /**
-     * Check if text only contains placeholders and whitespace.
-     * @param {string} text - Text to check.
-     * @returns {boolean} - True if text only contains placeholders.
-     */
-    isPlaceholderOnlyText(text) {
-        if (!text || typeof text !== "string") {
-            return false;
-        }
-        // Remove all placeholders from the text
-        const placeholderRegex = /\{[^}]+\}|\$\{[^}]+\}|%[sd]/g;
-        const textWithoutPlaceholders = text.replace(placeholderRegex, "").trim();
-        return textWithoutPlaceholders.length === 0;
-    }
     /**
      * Main translator function to process source file and create translations.
      * @param {string} file - Path to source file.
@@ -164,6 +152,10 @@ class TranslationService {
         const languageConcurrency = options.concurrencyLimit || 3;
         const targetLanguages = [...(options.targets || [])];
         await uiManager.log(`Processing ${targetLanguages.length} languages with concurrency of ${languageConcurrency}`);
+        // Initialize shared SourceCodeAnalyzer
+        console.log("Initializing Locai Engine...");
+        const sharedAnalyzer = new SourceCodeAnalyzer();
+        sharedAnalyzer.initialize();
         // Create shared orchestrators array to collect review queues
         const orchestrators = [];
         for (let i = 0; i < targetLanguages.length; i += languageConcurrency) {
@@ -180,6 +172,7 @@ class TranslationService {
                     ...options,
                     concurrencyLimit: 1,
                     progressOptions,
+                    sourceCodeAnalyzer: sharedAnalyzer,
                 });
                 orchestrators.push(orchestrator);
                 return this.processLanguage(targetLang, resolvedFile, flattenedSource, orchestrator, { ...options, progressOptions }, globalStats, comparison);
@@ -201,207 +194,7 @@ class TranslationService {
      * @returns {Promise<LanguageProcessResult>} - Status and messages for this language.
      */
     async processLanguage(targetLang, sourceFile, flattenedSource, orchestrator, options, globalStats, comparison) {
-        const langStartTime = Date.now();
-        try {
-            if (!targetLang || typeof targetLang !== "string") {
-                throw new Error("Invalid target language provided");
-            }
-            if (!sourceFile || typeof sourceFile !== "string") {
-                throw new Error("Invalid source file path provided");
-            }
-            if (!flattenedSource || typeof flattenedSource !== "object") {
-                throw new Error("Invalid flattened source data provided");
-            }
-            if (!orchestrator || typeof orchestrator.processTranslations !== "function") {
-                throw new Error("Invalid orchestrator instance provided");
-            }
-            if (!globalStats || typeof globalStats !== "object") {
-                throw new Error("Invalid global stats object provided");
-            }
-            const safeTargetLang = InputValidator.validateLanguageCode(targetLang, "target language");
-            await uiManager.log(`Starting translations for ${safeTargetLang}`);
-            let finalStatus = null;
-            let savedMessage = undefined;
-            statisticsManager.initLanguageStats(safeTargetLang);
-            const sourceDir = path.dirname(sourceFile);
-            const safeTargetFilename = `${safeTargetLang}.json`;
-            const targetPath = InputValidator.createSafeFilePath(sourceDir, safeTargetFilename);
-            let targetContent = {};
-            try {
-                targetContent = await FileManager.readJSON(targetPath);
-                if (!targetContent || typeof targetContent !== "object") {
-                    console.warn(`Invalid content in ${targetPath}, using empty object`);
-                    targetContent = {};
-                }
-            }
-            catch (err) {
-                if (err.code === "ENOENT") {
-                    await uiManager.log(`\ud83c\udd95 Creating new translation file for ${safeTargetLang}`);
-                }
-                else {
-                    if (options.debug) {
-                        console.warn(`Error reading ${targetPath}: ${err.message}, using empty object`);
-                    }
-                }
-                targetContent = {};
-            }
-            let flattenedTarget = {};
-            try {
-                flattenedTarget = ObjectTransformer.flatten(targetContent);
-                if (!flattenedTarget || typeof flattenedTarget !== "object") {
-                    flattenedTarget = {};
-                }
-            }
-            catch (err) {
-                console.warn(`Error flattening target content: ${err.message}, using empty object`);
-                flattenedTarget = {};
-            }
-            const missingKeys = [];
-            let hasPlaceholderOnlyChanges = false;
-            for (const [key, sourceText] of Object.entries(flattenedSource)) {
-                try {
-                    InputValidator.validateKey(key, "translation key");
-                    InputValidator.validateText(sourceText, "source text");
-                }
-                catch (keyError) {
-                    await uiManager.log(`\u26a0\ufe0f Skipping invalid key/text: ${keyError.message}`);
-                    globalStats.languages[safeTargetLang].failed++;
-                    globalStats.failed++;
-                    continue;
-                }
-                globalStats.languages[safeTargetLang].processed++;
-                if (this.isPlaceholderOnlyText(sourceText)) {
-                    const existingValue = flattenedTarget[key];
-                    if (existingValue !== sourceText) {
-                        flattenedTarget[key] = sourceText;
-                        hasPlaceholderOnlyChanges = true;
-                        if (options.debug) {
-                            await uiManager.log(`   Copying placeholder-only text: "${sourceText}"`);
-                        }
-                    }
-                    globalStats.languages[safeTargetLang].skipped++;
-                    globalStats.skipped++;
-                    continue;
-                }
-                const isNewKey = comparison.newKeys.includes(key);
-                const isModifiedKey = comparison.modifiedKeys.includes(key);
-                const keyExistsInTarget = key in flattenedTarget;
-                if (keyExistsInTarget && !options.forceUpdate && !isModifiedKey) {
-                    globalStats.languages[safeTargetLang].skipped++;
-                    globalStats.skipped++;
-                    continue;
-                }
-                missingKeys.push({
-                    key,
-                    text: sourceText,
-                    targetLang: safeTargetLang,
-                    existingTranslation: flattenedTarget[key],
-                    isModified: isModifiedKey,
-                    isNew: isNewKey,
-                });
-            }
-            if (missingKeys.length === 0 && !hasPlaceholderOnlyChanges) {
-                await uiManager.log(`All translations exist for ${safeTargetLang}`);
-                globalStats.languages[safeTargetLang].timeMs = Date.now() - langStartTime;
-                return { status: { completed: 0, total: 0, language: safeTargetLang } };
-            }
-            if (missingKeys.length > 0) {
-                await uiManager.log(`Found ${missingKeys.length} missing translations for ${safeTargetLang}`);
-            }
-            let results = [];
-            if (missingKeys.length > 0) {
-                try {
-                    results = await orchestrator.processTranslations(missingKeys);
-                    if (!Array.isArray(results)) {
-                        console.warn("Invalid results from orchestrator, using empty array");
-                        results = [];
-                    }
-                }
-                catch (err) {
-                    console.error(`Error processing translations for ${safeTargetLang}: ${err.message}`);
-                    results = [];
-                    if (globalStats.languages[safeTargetLang]) {
-                        globalStats.languages[safeTargetLang].failed += missingKeys.length;
-                        globalStats.failed += missingKeys.length;
-                    }
-                }
-            }
-            else {
-                if (hasPlaceholderOnlyChanges) {
-                    await uiManager.log(`Found placeholder-only changes for ${safeTargetLang}`);
-                }
-            }
-            try {
-                if (orchestrator?.progress &&
-                    typeof orchestrator.progress.getStatus === "function") {
-                    finalStatus = orchestrator.progress.getStatus();
-                }
-            }
-            catch (err) {
-                console.warn(`Error getting orchestrator status: ${err.message}`);
-            }
-            let validResults = [];
-            try {
-                validResults = results.filter((result) => result && result.success === true);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                validResults = validResults.filter((result) => result.key &&
-                    typeof result.key === "string" &&
-                    result.translated &&
-                    typeof result.translated === "string");
-            }
-            catch (err) {
-                console.warn(`Error filtering results: ${err.message}`);
-                validResults = [];
-            }
-            if (validResults.length > 0) {
-                validResults.forEach(({ key, translated }) => {
-                    if (translated) {
-                        flattenedTarget[key] = translated;
-                    }
-                });
-            }
-            const hasChangesToSave = validResults.length > 0 || hasPlaceholderOnlyChanges;
-            if (hasChangesToSave) {
-                const unflattened = ObjectTransformer.unflatten(flattenedTarget);
-                await FileManager.writeJSON(targetPath, unflattened);
-                globalStats.total += validResults.length;
-                globalStats.success += validResults.length;
-                globalStats.failed += results.length - validResults.length;
-                globalStats.languages[safeTargetLang].added += validResults.length;
-                globalStats.languages[safeTargetLang].failed +=
-                    results.length - validResults.length;
-                validResults.forEach((result) => {
-                    if (result.context) {
-                        const category = result.context.category || "general";
-                        globalStats.byCategory[category] =
-                            (globalStats.byCategory[category] || 0) + 1;
-                        if (!globalStats.details[category]) {
-                            globalStats.details[category] = {
-                                totalConfidence: 0,
-                                samples: 0,
-                            };
-                        }
-                        globalStats.details[category].totalConfidence +=
-                            result.context.confidence || 0;
-                        globalStats.details[category].samples++;
-                    }
-                });
-                savedMessage = `Translations saved: ${safeTargetLang}.json`;
-            }
-            globalStats.languages[safeTargetLang].timeMs = Date.now() - langStartTime;
-            return { status: finalStatus, savedMessage };
-        }
-        catch (error) {
-            const safeError = error.message.includes("outside working directory")
-                ? "Invalid file path detected"
-                : error.message;
-            await uiManager.log(`\n\u274c Error processing ${targetLang}: ${safeError}`);
-            if (globalStats.languages[targetLang]) {
-                globalStats.languages[targetLang].error = safeError;
-                globalStats.languages[targetLang].timeMs = Date.now() - langStartTime;
-            }
-            return { status: null, error: safeError };
-        }
+        return await LanguageProcessor.processLanguage(targetLang, sourceFile, flattenedSource, orchestrator, options, globalStats, comparison);
     }
     /**
      * Finalize translation process and save state.
@@ -415,6 +208,7 @@ class TranslationService {
     async finalizeTranslation(stateManager, projectRoot, currentState, globalStats, startTime, options) {
         globalStats.endTime = new Date().toISOString();
         globalStats.totalDuration = (Date.now() - startTime) / 1000;
+        globalStats.totalTime = globalStats.totalDuration;
         await uiManager.displayGlobalSummary(globalStats, (options.targets || []).length);
         // Save review queue if confidence scoring was enabled
         if (options.saveReviewQueue || options.minConfidence !== undefined) {

package/dist/types/context.d.ts

@@ -0,0 +1,13 @@
+export interface CodeContext {
+    filePath: string;
+    line: number;
+    component?: string;
+    usageSnippet?: string;
+    comments?: string[];
+    props?: Record<string, string>;
+}
+export interface SourceAnalyzerConfig {
+    enabled?: boolean;
+    include?: string[];
+    exclude?: string[];
+}

package/dist/types/context.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,58 @@
+import { OrchestratorOptions } from "../core/orchestrator.js";
+import { ContextConfig } from "../core/context-processor.js";
+export interface TranslationOptions extends Omit<OrchestratorOptions, "context"> {
+    source: string;
+    targets?: string[];
+    localesDir?: string;
+    debug?: boolean;
+    forceUpdate?: boolean;
+    syncOptions?: {
+        enabled?: boolean;
+        removeDeletedKeys?: boolean;
+    };
+    concurrencyLimit?: number;
+    saveReviewQueue?: boolean;
+    minConfidence?: number;
+    fileExtensions?: string[];
+    progressOptions?: any;
+    qualityChecks?: any;
+    styleGuide?: any;
+    context?: ContextConfig;
+    lengthControl?: any;
+}
+export interface GlobalStats {
+    total: number;
+    success: number;
+    failed: number;
+    skipped: number;
+    languages: Record<string, any>;
+    byCategory: Record<string, number>;
+    details: Record<string, {
+        totalConfidence: number;
+        samples: number;
+    }>;
+    error?: {
+        message: string;
+        time: string;
+        stack?: string;
+    };
+    orchestrators: any[];
+    endTime?: string;
+    totalDuration?: number;
+    totalTime: number;
+    startTime: string;
+}
+export interface MissingKey {
+    key: string;
+    text: string;
+    targetLang: string;
+    existingTranslation?: string;
+    isModified: boolean;
+    isNew: boolean;
+    issueDetails?: any;
+}
+export interface LanguageProcessResult {
+    status: any;
+    savedMessage?: string;
+    error?: string;
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ui-manager.js

@@ -74,10 +74,10 @@ export class UIManager {
                 if (details && details.samples > 0) {
                     const avgConfidence = details.totalConfidence / details.samples;
                     const confidenceStr = `${(avgConfidence * 100).toFixed(1)}%`;
-                    await this.log(`  ${category}: ${count} items (${confidenceStr} avg confidence)`);
+                    await this.log(`${category}: ${count} items (${confidenceStr} avg confidence)`);
                 }
                 else {
-                    await this.log(`  ${category}: ${count} items`);
+                    await this.log(`${category}: ${count} items`);
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "locai",
-	"version": "2.3.0",
+	"version": "2.5.0",
 	"type": "module",
 	"main": "dist/core/orchestrator.js",
 	"types": "dist/core/orchestrator.d.ts",
@@ -16,7 +16,7 @@
 		"start": "node dist/core/orchestrator.js",
 		"dev": "tsx src/core/orchestrator.js",
 		"build": "tsc",
-		"type-check": "tsc --noEmit",
+		"typecheck": "tsc --noEmit",
 		"lint": "eslint .",
 		"lint:fix": "eslint . --fix",
 		"format": "prettier --write \"**/*.{js,json,md,jsx,ts,tsx,css}\"",
@@ -27,18 +27,26 @@
 		"prepublishOnly": "pnpm build"
 	},
 	"keywords": [
-		"translation",
-		"localization",
 		"i18n",
-		"nextjs",
-		"ai-translation",
-		"cli",
+		"localization",
+		"translation",
+		"l10n",
+		"internationalization",
 		"automation",
+		"cli",
 		"llm",
+		"ai",
+		"artificial-intelligence",
 		"openai",
+		"anthropic",
+		"claude",
 		"gemini",
 		"deepseek",
-		"developer-tools"
+		"xai",
+		"vector-database",
+		"semantic-search",
+		"developer-tools",
+		"typescript"
 	],
 	"author": {
 		"name": "Ahmet Enes Dur",
@@ -64,8 +72,8 @@
 		"./translator": "./dist/commands/translator.js"
 	},
 	"dependencies": {
-		"axios": "1.13.1",
-		"c12": "^3.3.2",
+		"axios": "1.13.2",
+		"c12": "^3.3.3",
 		"commander": "^14.0.2",
 		"dot-properties": "^1.1.0",
 		"dotenv": "^17.2.3",
@@ -73,25 +81,26 @@
 		"gettext-parser": "^8.0.0",
 		"jiti": "^2.6.1",
 		"js-yaml": "^4.1.1",
-		"lru-cache": "^11.2.2",
+		"lru-cache": "^11.2.4",
 		"p-limit": "^7.2.0",
 		"prompts": "^2.4.2",
+		"ts-morph": "^27.0.2",
 		"vectra": "^0.11.1"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.39.1",
+		"@eslint/js": "^9.39.2",
 		"@types/js-yaml": "^4.0.9",
-		"@types/node": "^25.0.1",
+		"@types/node": "^25.0.3",
 		"@types/prompts": "^2.4.9",
-		"@vitest/coverage-v8": "^4.0.15",
-		"eslint": "^9.39.1",
+		"@vitest/coverage-v8": "^4.0.16",
+		"eslint": "^9.39.2",
 		"eslint-config-prettier": "^10.1.8",
 		"globals": "^16.5.0",
-		"prettier": "^3.6.2",
+		"prettier": "^3.7.4",
 		"std-mocks": "^2.0.0",
 		"tsx": "^4.21.0",
 		"typescript": "^5.9.3",
-		"vitest": "^4.0.15"
+		"vitest": "^4.0.16"
 	},
 	"files": [
 		"dist/"