@lingo.dev/compiler 0.1.0

package/build/metadata/manager.mjs

@@ -0,0 +1,123 @@
+import { logger } from "../utils/logger.mjs";
+import { DEFAULT_TIMEOUTS, withTimeout } from "../utils/timeout.mjs";
+import { getLingoDir } from "../utils/path-helpers.mjs";
+import fsPromises from "fs/promises";
+import path from "path";
+import fs from "fs";
+import lockfile from "proper-lockfile";
+
+//#region src/metadata/manager.ts
+function createEmptyMetadata() {
+	return {
+		entries: {},
+		stats: {
+			totalEntries: 0,
+			lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	};
+}
+function loadMetadata(path$1) {
+	return new MetadataManager(path$1).loadMetadata();
+}
+function cleanupExistingMetadata(metadataFilePath) {
+	logger.debug(`Attempting to cleanup metadata file: ${metadataFilePath}`);
+	try {
+		fs.unlinkSync(metadataFilePath);
+		logger.info(`🧹 Cleaned up build metadata file: ${metadataFilePath}`);
+	} catch (error) {
+		if (error.code === "ENOENT") logger.debug(`Metadata file already deleted or doesn't exist: ${metadataFilePath}`);
+		else logger.warn(`Failed to cleanup metadata file: ${error.message}`);
+	}
+}
+/**
+* Get the absolute path to the metadata file
+*
+* @param config - Config with sourceRoot, lingoDir, and environment
+* @returns Absolute path to metadata file
+*/
+function getMetadataPath(config) {
+	const filename = config.environment === "development" ? "metadata-dev.json" : "metadata-build.json";
+	return path.join(getLingoDir(config), filename);
+}
+var MetadataManager = class {
+	constructor(filePath) {
+		this.filePath = filePath;
+	}
+	/**
+	* Load metadata from disk
+	* Creates empty metadata if file doesn't exist
+	* Times out after 15 seconds to prevent indefinite hangs
+	*/
+	async loadMetadata() {
+		try {
+			const content = await withTimeout(fsPromises.readFile(this.filePath, "utf-8"), DEFAULT_TIMEOUTS.METADATA, "Load metadata");
+			return JSON.parse(content);
+		} catch (error) {
+			if (error.code === "ENOENT") return createEmptyMetadata();
+			throw error;
+		}
+	}
+	/**
+	* Save metadata to disk
+	* Times out after 15 seconds to prevent indefinite hangs
+	*/
+	async saveMetadata(metadata) {
+		await withTimeout(fsPromises.mkdir(path.dirname(this.filePath), { recursive: true }), DEFAULT_TIMEOUTS.FILE_IO, "Create metadata directory");
+		metadata.stats = {
+			totalEntries: Object.keys(metadata.entries).length,
+			lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const dir = path.dirname(this.filePath);
+		const base = path.basename(this.filePath);
+		const tmpPath = path.join(dir, `.${base}.tmp-${process.pid}-${Date.now()}`);
+		const json = JSON.stringify(metadata, null, 2);
+		await withTimeout(fsPromises.writeFile(tmpPath, json, "utf-8"), DEFAULT_TIMEOUTS.METADATA, "Save metadata (tmp write)");
+		try {
+			await withTimeout(fsPromises.rename(tmpPath, this.filePath), DEFAULT_TIMEOUTS.METADATA, "Save metadata (atomic rename)");
+		} catch (error) {
+			if (error && typeof error === "object" && "code" in error && error.code === "EPERM") {
+				await withTimeout(fsPromises.writeFile(this.filePath, json, "utf-8"), DEFAULT_TIMEOUTS.METADATA, "Save metadata (EPERM fallback direct write)");
+				return;
+			}
+			throw error;
+		} finally {
+			await fsPromises.unlink(tmpPath).catch(() => {});
+		}
+	}
+	/**
+	* Thread-safe save operation that atomically updates metadata with new entries
+	* Uses file locking to prevent concurrent write corruption
+	*
+	* @param entries - Translation entries to add/update
+	* @returns The updated metadata schema
+	*/
+	async saveMetadataWithEntries(entries) {
+		const lockDir = path.dirname(this.filePath);
+		await fsPromises.mkdir(lockDir, { recursive: true });
+		try {
+			await fsPromises.access(this.filePath);
+		} catch {
+			await fsPromises.writeFile(this.filePath, JSON.stringify(createEmptyMetadata(), null, 2), "utf-8");
+		}
+		const release = await lockfile.lock(this.filePath, {
+			retries: {
+				retries: 10,
+				minTimeout: 50,
+				maxTimeout: 1e3
+			},
+			stale: 2e3
+		});
+		try {
+			const currentMetadata = await this.loadMetadata();
+			for (const entry of entries) currentMetadata.entries[entry.hash] = entry;
+			await this.saveMetadata(currentMetadata);
+			return currentMetadata;
+		} finally {
+			await release();
+		}
+	}
+};
+
+//#endregion
+export { MetadataManager, cleanupExistingMetadata, createEmptyMetadata, getMetadataPath, loadMetadata };
+//# sourceMappingURL=manager.mjs.map

package/build/metadata/manager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.mjs","names":["path","error: any","filePath: string"],"sources":["../../src/metadata/manager.ts"],"sourcesContent":["import fsPromises from \"fs/promises\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport lockfile from \"proper-lockfile\";\nimport type { MetadataSchema, PathConfig, TranslationEntry } from \"../types\";\nimport { DEFAULT_TIMEOUTS, withTimeout } from \"../utils/timeout\";\nimport { getLingoDir } from \"../utils/path-helpers\";\nimport { logger } from \"../utils/logger\";\n\nexport function createEmptyMetadata(): MetadataSchema {\n  return {\n    entries: {},\n    stats: {\n      totalEntries: 0,\n      lastUpdated: new Date().toISOString(),\n    },\n  };\n}\n\nexport function loadMetadata(path: string) {\n  return new MetadataManager(path).loadMetadata();\n}\n\nexport function cleanupExistingMetadata(metadataFilePath: string) {\n  // General cleanup. Delete metadata and stop the server if any was started.\n  logger.debug(`Attempting to cleanup metadata file: ${metadataFilePath}`);\n\n  try {\n    fs.unlinkSync(metadataFilePath);\n    logger.info(`🧹 Cleaned up build metadata file: ${metadataFilePath}`);\n  } catch (error: any) {\n    // Ignore if file doesn't exist\n    if (error.code === \"ENOENT\") {\n      logger.debug(\n        `Metadata file already deleted or doesn't exist: ${metadataFilePath}`,\n      );\n    } else {\n      logger.warn(`Failed to cleanup metadata file: ${error.message}`);\n    }\n  }\n}\n\n/**\n * Get the absolute path to the metadata file\n *\n * @param config - Config with sourceRoot, lingoDir, and environment\n * @returns Absolute path to metadata file\n */\nexport function getMetadataPath(config: PathConfig): string {\n  const filename =\n    // Similar to next keeping dev build separate, let's keep the build metadata clean of any dev mode additions\n    config.environment === \"development\"\n      ? \"metadata-dev.json\"\n      : \"metadata-build.json\";\n  return path.join(getLingoDir(config), filename);\n}\n\nexport class MetadataManager {\n  constructor(private readonly filePath: string) {}\n\n  /**\n   * Load metadata from disk\n   * Creates empty metadata if file doesn't exist\n   * Times out after 15 seconds to prevent indefinite hangs\n   */\n  async loadMetadata(): Promise<MetadataSchema> {\n    try {\n      const content = await withTimeout(\n        fsPromises.readFile(this.filePath, \"utf-8\"),\n        DEFAULT_TIMEOUTS.METADATA,\n        \"Load metadata\",\n      );\n      return JSON.parse(content) as MetadataSchema;\n    } catch (error: any) {\n      if (error.code === \"ENOENT\") {\n        // File doesn't exist, create new metadata\n        return createEmptyMetadata();\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Save metadata to disk\n   * Times out after 15 seconds to prevent indefinite hangs\n   */\n  private async saveMetadata(metadata: MetadataSchema): Promise<void> {\n    await withTimeout(\n      fsPromises.mkdir(path.dirname(this.filePath), { recursive: true }),\n      DEFAULT_TIMEOUTS.FILE_IO,\n      \"Create metadata directory\",\n    );\n\n    metadata.stats = {\n      totalEntries: Object.keys(metadata.entries).length,\n      lastUpdated: new Date().toISOString(),\n    };\n\n    // Per LLM writing to a file is not an atomic operation while rename is, so nobody should get partial content.\n    // Sounds reasonable.\n    const dir = path.dirname(this.filePath);\n    const base = path.basename(this.filePath);\n\n    // Keep temp file in the same directory to maximize chance that rename is atomic\n    const tmpPath = path.join(dir, `.${base}.tmp-${process.pid}-${Date.now()}`);\n\n    const json = JSON.stringify(metadata, null, 2);\n\n    await withTimeout(\n      fsPromises.writeFile(tmpPath, json, \"utf-8\"),\n      DEFAULT_TIMEOUTS.METADATA,\n      \"Save metadata (tmp write)\",\n    );\n\n    try {\n      // TODO (AleksandrSl 14/12/2025): LLM says that we may want to remove older file first for windows, but it seems lo work fine as is.\n      await withTimeout(\n        fsPromises.rename(tmpPath, this.filePath),\n        DEFAULT_TIMEOUTS.METADATA,\n        \"Save metadata (atomic rename)\",\n      );\n    } catch (error) {\n      // On Windows, rename() can fail with EPERM if something briefly holds the file.\n      // As a fallback, try writing directly to the destination (not atomic).\n      if (\n        error &&\n        typeof error === \"object\" &&\n        \"code\" in error &&\n        error.code === \"EPERM\"\n      ) {\n        await withTimeout(\n          fsPromises.writeFile(this.filePath, json, \"utf-8\"),\n          DEFAULT_TIMEOUTS.METADATA,\n          \"Save metadata (EPERM fallback direct write)\",\n        );\n        return;\n      }\n      throw error;\n    } finally {\n      // Best-effort cleanup if rename failed for some reason\n      await fsPromises.unlink(tmpPath).catch(() => {});\n    }\n  }\n\n  /**\n   * Thread-safe save operation that atomically updates metadata with new entries\n   * Uses file locking to prevent concurrent write corruption\n   *\n   * @param entries - Translation entries to add/update\n   * @returns The updated metadata schema\n   */\n  async saveMetadataWithEntries(\n    entries: TranslationEntry[],\n  ): Promise<MetadataSchema> {\n    const lockDir = path.dirname(this.filePath);\n\n    await fsPromises.mkdir(lockDir, { recursive: true });\n\n    try {\n      await fsPromises.access(this.filePath);\n    } catch {\n      await fsPromises.writeFile(\n        this.filePath,\n        JSON.stringify(createEmptyMetadata(), null, 2),\n        \"utf-8\",\n      );\n    }\n\n    const release = await lockfile.lock(this.filePath, {\n      retries: {\n        retries: 10,\n        minTimeout: 50,\n        maxTimeout: 1000,\n      },\n      stale: 2000,\n    });\n\n    try {\n      // Re-load metadata inside lock to get latest state\n      const currentMetadata = await this.loadMetadata();\n      for (const entry of entries) {\n        currentMetadata.entries[entry.hash] = entry;\n      }\n      await this.saveMetadata(currentMetadata);\n      return currentMetadata;\n    } finally {\n      await release();\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,sBAAsC;AACpD,QAAO;EACL,SAAS,EAAE;EACX,OAAO;GACL,cAAc;GACd,8BAAa,IAAI,MAAM,EAAC,aAAa;GACtC;EACF;;AAGH,SAAgB,aAAa,QAAc;AACzC,QAAO,IAAI,gBAAgBA,OAAK,CAAC,cAAc;;AAGjD,SAAgB,wBAAwB,kBAA0B;AAEhE,QAAO,MAAM,wCAAwC,mBAAmB;AAExE,KAAI;AACF,KAAG,WAAW,iBAAiB;AAC/B,SAAO,KAAK,sCAAsC,mBAAmB;UAC9DC,OAAY;AAEnB,MAAI,MAAM,SAAS,SACjB,QAAO,MACL,mDAAmD,mBACpD;MAED,QAAO,KAAK,oCAAoC,MAAM,UAAU;;;;;;;;;AAWtE,SAAgB,gBAAgB,QAA4B;CAC1D,MAAM,WAEJ,OAAO,gBAAgB,gBACnB,sBACA;AACN,QAAO,KAAK,KAAK,YAAY,OAAO,EAAE,SAAS;;AAGjD,IAAa,kBAAb,MAA6B;CAC3B,YAAY,AAAiBC,UAAkB;EAAlB;;;;;;;CAO7B,MAAM,eAAwC;AAC5C,MAAI;GACF,MAAM,UAAU,MAAM,YACpB,WAAW,SAAS,KAAK,UAAU,QAAQ,EAC3C,iBAAiB,UACjB,gBACD;AACD,UAAO,KAAK,MAAM,QAAQ;WACnBD,OAAY;AACnB,OAAI,MAAM,SAAS,SAEjB,QAAO,qBAAqB;AAE9B,SAAM;;;;;;;CAQV,MAAc,aAAa,UAAyC;AAClE,QAAM,YACJ,WAAW,MAAM,KAAK,QAAQ,KAAK,SAAS,EAAE,EAAE,WAAW,MAAM,CAAC,EAClE,iBAAiB,SACjB,4BACD;AAED,WAAS,QAAQ;GACf,cAAc,OAAO,KAAK,SAAS,QAAQ,CAAC;GAC5C,8BAAa,IAAI,MAAM,EAAC,aAAa;GACtC;EAID,MAAM,MAAM,KAAK,QAAQ,KAAK,SAAS;EACvC,MAAM,OAAO,KAAK,SAAS,KAAK,SAAS;EAGzC,MAAM,UAAU,KAAK,KAAK,KAAK,IAAI,KAAK,OAAO,QAAQ,IAAI,GAAG,KAAK,KAAK,GAAG;EAE3E,MAAM,OAAO,KAAK,UAAU,UAAU,MAAM,EAAE;AAE9C,QAAM,YACJ,WAAW,UAAU,SAAS,MAAM,QAAQ,EAC5C,iBAAiB,UACjB,4BACD;AAED,MAAI;AAEF,SAAM,YACJ,WAAW,OAAO,SAAS,KAAK,SAAS,EACzC,iBAAiB,UACjB,gCACD;WACM,OAAO;AAGd,OACE,SACA,OAAO,UAAU,YACjB,UAAU,SACV,MAAM,SAAS,SACf;AACA,UAAM,YACJ,WAAW,UAAU,KAAK,UAAU,MAAM,QAAQ,EAClD,iBAAiB,UACjB,8CACD;AACD;;AAEF,SAAM;YACE;AAER,SAAM,WAAW,OAAO,QAAQ,CAAC,YAAY,GAAG;;;;;;;;;;CAWpD,MAAM,wBACJ,SACyB;EACzB,MAAM,UAAU,KAAK,QAAQ,KAAK,SAAS;AAE3C,QAAM,WAAW,MAAM,SAAS,EAAE,WAAW,MAAM,CAAC;AAEpD,MAAI;AACF,SAAM,WAAW,OAAO,KAAK,SAAS;UAChC;AACN,SAAM,WAAW,UACf,KAAK,UACL,KAAK,UAAU,qBAAqB,EAAE,MAAM,EAAE,EAC9C,QACD;;EAGH,MAAM,UAAU,MAAM,SAAS,KAAK,KAAK,UAAU;GACjD,SAAS;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACb;GACD,OAAO;GACR,CAAC;AAEF,MAAI;GAEF,MAAM,kBAAkB,MAAM,KAAK,cAAc;AACjD,QAAK,MAAM,SAAS,QAClB,iBAAgB,QAAQ,MAAM,QAAQ;AAExC,SAAM,KAAK,aAAa,gBAAgB;AACxC,UAAO;YACC;AACR,SAAM,SAAS"}

package/build/plugin/build-translator.cjs

@@ -0,0 +1,198 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_logger = require('../utils/logger.cjs');
+const require_api = require('../translators/api.cjs');
+const require_cache_factory = require('../translators/cache-factory.cjs');
+const require_manager = require('../metadata/manager.cjs');
+const require_translation_server = require('../translation-server/translation-server.cjs');
+let fs_promises = require("fs/promises");
+fs_promises = require_rolldown_runtime.__toESM(fs_promises);
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
+
+//#region src/plugin/build-translator.ts
+/**
+* Build-time translation processor
+*
+* Handles translation generation and validation at build time
+* Supports two modes:
+* - "translate": Generate all translations, fail if translation fails
+* - "cache-only": Validate cache completeness, fail if incomplete
+*/
+/**
+* Process translations at build time
+*
+* @throws Error if validation or translation fails (causes build to fail)
+*/
+async function processBuildTranslations(options) {
+	const { config, publicOutputPath, metadataFilePath } = options;
+	const buildMode = process.env.LINGO_BUILD_MODE || config.buildMode;
+	require_logger.logger.info(`🌍 Build mode: ${buildMode}`);
+	if (metadataFilePath) require_logger.logger.info(`📋 Using build metadata file: ${metadataFilePath}`);
+	const metadata = await require_manager.loadMetadata(metadataFilePath);
+	if (!metadata || Object.keys(metadata.entries).length === 0) {
+		require_logger.logger.info("No translations to process (metadata is empty)");
+		return {
+			success: true,
+			stats: {}
+		};
+	}
+	const totalEntries = Object.keys(metadata.entries).length;
+	require_logger.logger.info(`📊 Found ${totalEntries} translatable entries`);
+	const cache = require_cache_factory.createCache(config);
+	if (buildMode === "cache-only") {
+		require_logger.logger.info("🔍 Validating translation cache...");
+		await validateCache(config, metadata, cache);
+		require_logger.logger.info("✅ Cache validation passed");
+		if (publicOutputPath) await copyStaticFiles(config, publicOutputPath, metadata, cache);
+		return {
+			success: true,
+			stats: buildCacheStats(config, metadata)
+		};
+	}
+	require_logger.logger.info("🔄 Generating translations...");
+	let translationServer;
+	try {
+		translationServer = await require_translation_server.startTranslationServer({
+			startPort: config.dev.translationServerStartPort,
+			onError: (err) => {
+				require_logger.logger.error("Translation server error:", err);
+			},
+			config
+		});
+		const needsSourceLocale = config.pluralization?.enabled !== false;
+		const allLocales = needsSourceLocale ? [config.sourceLocale, ...config.targetLocales] : config.targetLocales;
+		require_logger.logger.info(`Processing translations for ${allLocales.length} locale(s)${needsSourceLocale ? " (including source locale for pluralization)" : ""}...`);
+		const stats = {};
+		const errors = [];
+		const localePromises = allLocales.map(async (locale) => {
+			require_logger.logger.info(`Translating to ${locale}...`);
+			const result = await translationServer.translateAll(locale);
+			stats[locale] = {
+				total: totalEntries,
+				translated: Object.keys(result.translations).length,
+				failed: result.errors.length
+			};
+			if (result.errors.length > 0) {
+				require_logger.logger.warn(`⚠️  ${result.errors.length} translation error(s) for ${locale}`);
+				errors.push({
+					locale,
+					error: `${result.errors.length} translation(s) failed`
+				});
+			} else require_logger.logger.info(`✅ ${locale} completed successfully`);
+		});
+		await Promise.all(localePromises);
+		if (errors.length > 0) {
+			const errorMsg = formatTranslationErrors(errors);
+			require_logger.logger.error(errorMsg);
+			process.exit(1);
+		}
+		if (publicOutputPath) await copyStaticFiles(config, publicOutputPath, metadata, cache);
+		require_logger.logger.info("✅ Translation generation completed successfully");
+		return {
+			success: true,
+			stats
+		};
+	} catch (error) {
+		require_logger.logger.error("❌ Translation generation failed:", error);
+		process.exit(1);
+	} finally {
+		if (translationServer) {
+			await translationServer.stop();
+			require_logger.logger.info("✅ Translation server stopped");
+		}
+	}
+}
+/**
+* Validate that all required translations exist in cache
+* @throws Error if cache is incomplete or missing
+*/
+async function validateCache(config, metadata, cache) {
+	const allHashes = Object.keys(metadata.entries);
+	const missingLocales = [];
+	const incompleteLocales = [];
+	const allLocales = config.pluralization?.enabled !== false ? [config.sourceLocale, ...config.targetLocales] : config.targetLocales;
+	for (const locale of allLocales) try {
+		const entries = await cache.get(locale);
+		if (Object.keys(entries).length === 0) {
+			missingLocales.push(locale);
+			require_logger.logger.debug(`Cache file not found or empty for ${locale}`);
+			continue;
+		}
+		const missingHashes = allHashes.filter((hash) => !entries[hash]);
+		if (missingHashes.length > 0) {
+			incompleteLocales.push({
+				locale,
+				missing: missingHashes.length,
+				total: allHashes.length
+			});
+			require_logger.logger.debug(`Missing hashes in ${locale}: ${missingHashes.slice(0, 5).join(", ")}${missingHashes.length > 5 ? "..." : ""}`);
+		}
+	} catch (error) {
+		missingLocales.push(locale);
+		require_logger.logger.debug(`Failed to read cache for ${locale}:`, error);
+	}
+	if (missingLocales.length > 0 || incompleteLocales.length > 0) {
+		const errorMsg = formatCacheValidationError(missingLocales, incompleteLocales);
+		require_logger.logger.error(errorMsg);
+		process.exit(1);
+	}
+}
+function buildCacheStats(config, metadata) {
+	const totalEntries = Object.keys(metadata.entries).length;
+	const stats = {};
+	const allLocales = config.pluralization?.enabled !== false ? [config.sourceLocale, ...config.targetLocales] : config.targetLocales;
+	for (const locale of allLocales) stats[locale] = {
+		total: totalEntries,
+		translated: totalEntries,
+		failed: 0
+	};
+	return stats;
+}
+async function copyStaticFiles(config, publicOutputPath, metadata, cache) {
+	require_logger.logger.info(`📦 Generating static translation files in ${publicOutputPath}`);
+	await fs_promises.default.mkdir(publicOutputPath, { recursive: true });
+	const usedHashes = new Set(Object.keys(metadata.entries));
+	require_logger.logger.info(`📊 Filtering translations to ${usedHashes.size} used hash(es)`);
+	const allLocales = config.pluralization?.enabled !== false ? [config.sourceLocale, ...config.targetLocales] : config.targetLocales;
+	for (const locale of allLocales) {
+		const publicFilePath = path.default.join(publicOutputPath, `${locale}.json`);
+		try {
+			const entries = await cache.get(locale, Array.from(usedHashes));
+			const outputData = require_api.dictionaryFrom(locale, entries);
+			await fs_promises.default.writeFile(publicFilePath, JSON.stringify(outputData, null, 2), "utf-8");
+			require_logger.logger.info(`✓ Generated ${locale}.json (${Object.keys(entries).length} translations)`);
+		} catch (error) {
+			require_logger.logger.error(`❌ Failed to generate ${locale}.json:`, error);
+			process.exit(1);
+		}
+	}
+}
+function formatCacheValidationError(missingLocales, incompleteLocales) {
+	let msg = "❌ Cache validation failed in cache-only mode:\n\n";
+	if (missingLocales.length > 0) {
+		msg += `  📁 Missing cache files:\n`;
+		msg += missingLocales.map((locale) => `    - ${locale}.json`).join("\n");
+		msg += "\n\n";
+	}
+	if (incompleteLocales.length > 0) {
+		msg += `  📊 Incomplete cache:\n`;
+		msg += incompleteLocales.map((item) => `    - ${item.locale}: ${item.missing}/${item.total} translations missing`).join("\n");
+		msg += "\n\n";
+	}
+	msg += `  💡 To fix:\n`;
+	msg += `    1. Set LINGO_BUILD_MODE=translate to generate translations\n`;
+	msg += `    2. Commit the generated .lingo/cache/*.json files\n`;
+	msg += `    3. Ensure translation API keys are available if generating translations`;
+	return msg;
+}
+function formatTranslationErrors(errors) {
+	let msg = "❌ Translation generation failed:\n\n";
+	msg += errors.map((err) => `  - ${err.locale}: ${err.error}`).join("\n");
+	msg += "\n\n";
+	msg += `  💡 Translation errors must be resolved in "translate" mode.\n`;
+	msg += `     Check translation server logs for details.`;
+	return msg;
+}
+
+//#endregion
+exports.processBuildTranslations = processBuildTranslations;

package/build/plugin/build-translator.mjs

@@ -0,0 +1,196 @@
+import { logger } from "../utils/logger.mjs";
+import { dictionaryFrom } from "../translators/api.mjs";
+import { createCache } from "../translators/cache-factory.mjs";
+import { loadMetadata } from "../metadata/manager.mjs";
+import { startTranslationServer } from "../translation-server/translation-server.mjs";
+import fsPromises from "fs/promises";
+import path from "path";
+
+//#region src/plugin/build-translator.ts
+/**
+* Build-time translation processor
+*
+* Handles translation generation and validation at build time
+* Supports two modes:
+* - "translate": Generate all translations, fail if translation fails
+* - "cache-only": Validate cache completeness, fail if incomplete
+*/
+/**
+* Process translations at build time
+*
+* @throws Error if validation or translation fails (causes build to fail)
+*/
+async function processBuildTranslations(options) {
+	const { config, publicOutputPath, metadataFilePath } = options;
+	const buildMode = process.env.LINGO_BUILD_MODE || config.buildMode;
+	logger.info(`🌍 Build mode: ${buildMode}`);
+	if (metadataFilePath) logger.info(`📋 Using build metadata file: ${metadataFilePath}`);
+	const metadata = await loadMetadata(metadataFilePath);
+	if (!metadata || Object.keys(metadata.entries).length === 0) {
+		logger.info("No translations to process (metadata is empty)");
+		return {
+			success: true,
+			stats: {}
+		};
+	}
+	const totalEntries = Object.keys(metadata.entries).length;
+	logger.info(`📊 Found ${totalEntries} translatable entries`);
+	const cache = createCache(config);
+	if (buildMode === "cache-only") {
+		logger.info("🔍 Validating translation cache...");
+		await validateCache(config, metadata, cache);
+		logger.info("✅ Cache validation passed");
+		if (publicOutputPath) await copyStaticFiles(config, publicOutputPath, metadata, cache);
+		return {
+			success: true,
+			stats: buildCacheStats(config, metadata)
+		};
+	}
+	logger.info("🔄 Generating translations...");
+	let translationServer;
+	try {
+		translationServer = await startTranslationServer({
+			startPort: config.dev.translationServerStartPort,
+			onError: (err) => {
+				logger.error("Translation server error:", err);
+			},
+			config
+		});
+		const needsSourceLocale = config.pluralization?.enabled !== false;
+		const allLocales = needsSourceLocale ? [config.sourceLocale, ...config.targetLocales] : config.targetLocales;
+		logger.info(`Processing translations for ${allLocales.length} locale(s)${needsSourceLocale ? " (including source locale for pluralization)" : ""}...`);
+		const stats = {};
+		const errors = [];
+		const localePromises = allLocales.map(async (locale) => {
+			logger.info(`Translating to ${locale}...`);
+			const result = await translationServer.translateAll(locale);
+			stats[locale] = {
+				total: totalEntries,
+				translated: Object.keys(result.translations).length,
+				failed: result.errors.length
+			};
+			if (result.errors.length > 0) {
+				logger.warn(`⚠️  ${result.errors.length} translation error(s) for ${locale}`);
+				errors.push({
+					locale,
+					error: `${result.errors.length} translation(s) failed`
+				});
+			} else logger.info(`✅ ${locale} completed successfully`);
+		});
+		await Promise.all(localePromises);
+		if (errors.length > 0) {
+			const errorMsg = formatTranslationErrors(errors);
+			logger.error(errorMsg);
+			process.exit(1);
+		}
+		if (publicOutputPath) await copyStaticFiles(config, publicOutputPath, metadata, cache);
+		logger.info("✅ Translation generation completed successfully");
+		return {
+			success: true,
+			stats
+		};
+	} catch (error) {
+		logger.error("❌ Translation generation failed:", error);
+		process.exit(1);
+	} finally {
+		if (translationServer) {
+			await translationServer.stop();
+			logger.info("✅ Translation server stopped");
+		}
+	}
+}
+/**
+* Validate that all required translations exist in cache
+* @throws Error if cache is incomplete or missing
+*/
+async function validateCache(config, metadata, cache) {
+	const allHashes = Object.keys(metadata.entries);
+	const missingLocales = [];
+	const incompleteLocales = [];
+	const allLocales = config.pluralization?.enabled !== false ? [config.sourceLocale, ...config.targetLocales] : config.targetLocales;
+	for (const locale of allLocales) try {
+		const entries = await cache.get(locale);
+		if (Object.keys(entries).length === 0) {
+			missingLocales.push(locale);
+			logger.debug(`Cache file not found or empty for ${locale}`);
+			continue;
+		}
+		const missingHashes = allHashes.filter((hash) => !entries[hash]);
+		if (missingHashes.length > 0) {
+			incompleteLocales.push({
+				locale,
+				missing: missingHashes.length,
+				total: allHashes.length
+			});
+			logger.debug(`Missing hashes in ${locale}: ${missingHashes.slice(0, 5).join(", ")}${missingHashes.length > 5 ? "..." : ""}`);
+		}
+	} catch (error) {
+		missingLocales.push(locale);
+		logger.debug(`Failed to read cache for ${locale}:`, error);
+	}
+	if (missingLocales.length > 0 || incompleteLocales.length > 0) {
+		const errorMsg = formatCacheValidationError(missingLocales, incompleteLocales);
+		logger.error(errorMsg);
+		process.exit(1);
+	}
+}
+function buildCacheStats(config, metadata) {
+	const totalEntries = Object.keys(metadata.entries).length;
+	const stats = {};
+	const allLocales = config.pluralization?.enabled !== false ? [config.sourceLocale, ...config.targetLocales] : config.targetLocales;
+	for (const locale of allLocales) stats[locale] = {
+		total: totalEntries,
+		translated: totalEntries,
+		failed: 0
+	};
+	return stats;
+}
+async function copyStaticFiles(config, publicOutputPath, metadata, cache) {
+	logger.info(`📦 Generating static translation files in ${publicOutputPath}`);
+	await fsPromises.mkdir(publicOutputPath, { recursive: true });
+	const usedHashes = new Set(Object.keys(metadata.entries));
+	logger.info(`📊 Filtering translations to ${usedHashes.size} used hash(es)`);
+	const allLocales = config.pluralization?.enabled !== false ? [config.sourceLocale, ...config.targetLocales] : config.targetLocales;
+	for (const locale of allLocales) {
+		const publicFilePath = path.join(publicOutputPath, `${locale}.json`);
+		try {
+			const entries = await cache.get(locale, Array.from(usedHashes));
+			const outputData = dictionaryFrom(locale, entries);
+			await fsPromises.writeFile(publicFilePath, JSON.stringify(outputData, null, 2), "utf-8");
+			logger.info(`✓ Generated ${locale}.json (${Object.keys(entries).length} translations)`);
+		} catch (error) {
+			logger.error(`❌ Failed to generate ${locale}.json:`, error);
+			process.exit(1);
+		}
+	}
+}
+function formatCacheValidationError(missingLocales, incompleteLocales) {
+	let msg = "❌ Cache validation failed in cache-only mode:\n\n";
+	if (missingLocales.length > 0) {
+		msg += `  📁 Missing cache files:\n`;
+		msg += missingLocales.map((locale) => `    - ${locale}.json`).join("\n");
+		msg += "\n\n";
+	}
+	if (incompleteLocales.length > 0) {
+		msg += `  📊 Incomplete cache:\n`;
+		msg += incompleteLocales.map((item) => `    - ${item.locale}: ${item.missing}/${item.total} translations missing`).join("\n");
+		msg += "\n\n";
+	}
+	msg += `  💡 To fix:\n`;
+	msg += `    1. Set LINGO_BUILD_MODE=translate to generate translations\n`;
+	msg += `    2. Commit the generated .lingo/cache/*.json files\n`;
+	msg += `    3. Ensure translation API keys are available if generating translations`;
+	return msg;
+}
+function formatTranslationErrors(errors) {
+	let msg = "❌ Translation generation failed:\n\n";
+	msg += errors.map((err) => `  - ${err.locale}: ${err.error}`).join("\n");
+	msg += "\n\n";
+	msg += `  💡 Translation errors must be resolved in "translate" mode.\n`;
+	msg += `     Check translation server logs for details.`;
+	return msg;
+}
+
+//#endregion
+export { processBuildTranslations };
+//# sourceMappingURL=build-translator.mjs.map

package/build/plugin/build-translator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-translator.mjs","names":["translationServer: TranslationServer | undefined","stats: BuildTranslationResult[\"stats\"]","errors: Array<{ locale: LocaleCode; error: string }>","missingLocales: string[]","incompleteLocales: Array<{\n    locale: LocaleCode;\n    missing: number;\n    total: number;\n  }>","fs"],"sources":["../../src/plugin/build-translator.ts"],"sourcesContent":["/**\n * Build-time translation processor\n *\n * Handles translation generation and validation at build time\n * Supports two modes:\n * - \"translate\": Generate all translations, fail if translation fails\n * - \"cache-only\": Validate cache completeness, fail if incomplete\n */\n// TODO (AleksandrSl 08/12/2025): Add ICU validation for messages? The problem is that we don't know which will be rendered as a simple text\nimport fs from \"fs/promises\";\nimport path from \"path\";\nimport type { LingoConfig, MetadataSchema } from \"../types\";\nimport { logger } from \"../utils/logger\";\nimport {\n  startTranslationServer,\n  type TranslationServer,\n} from \"../translation-server\";\nimport { loadMetadata } from \"../metadata/manager\";\nimport { createCache, type TranslationCache } from \"../translators\";\nimport { dictionaryFrom } from \"../translators/api\";\nimport type { LocaleCode } from \"lingo.dev/spec\";\n\nexport interface BuildTranslationOptions {\n  config: LingoConfig;\n  publicOutputPath: string;\n  metadataFilePath: string;\n}\n\nexport interface BuildTranslationResult {\n  /**\n   * Whether the build succeeded\n   */\n  success: boolean;\n\n  /**\n   * Error message if build failed\n   */\n  error?: string;\n\n  /**\n   * Translation statistics per locale\n   */\n  stats: Record<\n    string,\n    {\n      total: number;\n      translated: number;\n      failed: number;\n    }\n  >;\n}\n\n/**\n * Process translations at build time\n *\n * @throws Error if validation or translation fails (causes build to fail)\n */\nexport async function processBuildTranslations(\n  options: BuildTranslationOptions,\n): Promise<BuildTranslationResult> {\n  const { config, publicOutputPath, metadataFilePath } = options;\n\n  // Determine build mode (env var > options > config)\n  const buildMode =\n    (process.env.LINGO_BUILD_MODE as \"translate\" | \"cache-only\") ||\n    config.buildMode;\n\n  logger.info(`🌍 Build mode: ${buildMode}`);\n\n  if (metadataFilePath) {\n    logger.info(`📋 Using build metadata file: ${metadataFilePath}`);\n  }\n\n  const metadata = await loadMetadata(metadataFilePath);\n\n  if (!metadata || Object.keys(metadata.entries).length === 0) {\n    logger.info(\"No translations to process (metadata is empty)\");\n    return {\n      success: true,\n      stats: {},\n    };\n  }\n\n  const totalEntries = Object.keys(metadata.entries).length;\n  logger.info(`📊 Found ${totalEntries} translatable entries`);\n\n  const cache = createCache(config);\n\n  // Handle cache-only mode\n  if (buildMode === \"cache-only\") {\n    logger.info(\"🔍 Validating translation cache...\");\n    await validateCache(config, metadata, cache);\n    logger.info(\"✅ Cache validation passed\");\n\n    if (publicOutputPath) {\n      await copyStaticFiles(config, publicOutputPath, metadata, cache);\n    }\n\n    return {\n      success: true,\n      stats: buildCacheStats(config, metadata),\n    };\n  }\n\n  // Handle translate mode\n  logger.info(\"🔄 Generating translations...\");\n  let translationServer: TranslationServer | undefined;\n\n  try {\n    translationServer = await startTranslationServer({\n      startPort: config.dev.translationServerStartPort,\n      onError: (err) => {\n        logger.error(\"Translation server error:\", err);\n      },\n      config,\n    });\n\n    // When pluralization is enabled, we need to generate the source locale file too\n    // because pluralization modifies the sourceText\n    const needsSourceLocale = config.pluralization?.enabled !== false;\n    const allLocales = needsSourceLocale\n      ? [config.sourceLocale, ...config.targetLocales]\n      : config.targetLocales;\n\n    logger.info(\n      `Processing translations for ${allLocales.length} locale(s)${needsSourceLocale ? \" (including source locale for pluralization)\" : \"\"}...`,\n    );\n\n    const stats: BuildTranslationResult[\"stats\"] = {};\n    const errors: Array<{ locale: LocaleCode; error: string }> = [];\n\n    // Translate all locales in parallel\n    const localePromises = allLocales.map(async (locale) => {\n      logger.info(`Translating to ${locale}...`);\n\n      const result = await translationServer!.translateAll(locale);\n\n      stats[locale] = {\n        total: totalEntries,\n        translated: Object.keys(result.translations).length,\n        failed: result.errors.length,\n      };\n\n      if (result.errors.length > 0) {\n        logger.warn(\n          `⚠️  ${result.errors.length} translation error(s) for ${locale}`,\n        );\n        errors.push({\n          locale,\n          error: `${result.errors.length} translation(s) failed`,\n        });\n      } else {\n        logger.info(`✅ ${locale} completed successfully`);\n      }\n    });\n\n    await Promise.all(localePromises);\n\n    // Fail build if any translations failed in translate mode\n    if (errors.length > 0) {\n      const errorMsg = formatTranslationErrors(errors);\n      logger.error(errorMsg);\n      process.exit(1);\n    }\n\n    // Copy cache to public directory if requested\n    if (publicOutputPath) {\n      await copyStaticFiles(config, publicOutputPath, metadata, cache);\n    }\n\n    logger.info(\"✅ Translation generation completed successfully\");\n\n    return {\n      success: true,\n      stats,\n    };\n  } catch (error) {\n    logger.error(\"❌ Translation generation failed:\", error);\n    process.exit(1);\n  } finally {\n    if (translationServer) {\n      await translationServer.stop();\n      logger.info(\"✅ Translation server stopped\");\n    }\n  }\n}\n\n/**\n * Validate that all required translations exist in cache\n * @throws Error if cache is incomplete or missing\n */\nasync function validateCache(\n  config: LingoConfig,\n  metadata: MetadataSchema,\n  cache: TranslationCache,\n): Promise<void> {\n  const allHashes = Object.keys(metadata.entries);\n  const missingLocales: string[] = [];\n  const incompleteLocales: Array<{\n    locale: LocaleCode;\n    missing: number;\n    total: number;\n  }> = [];\n\n  // Include source locale if pluralization is enabled\n  const needsSourceLocale = config.pluralization?.enabled !== false;\n  const allLocales = needsSourceLocale\n    ? [config.sourceLocale, ...config.targetLocales]\n    : config.targetLocales;\n\n  for (const locale of allLocales) {\n    try {\n      const entries = await cache.get(locale);\n\n      if (Object.keys(entries).length === 0) {\n        missingLocales.push(locale);\n        logger.debug(`Cache file not found or empty for ${locale}`);\n        continue;\n      }\n\n      const missingHashes = allHashes.filter((hash) => !entries[hash]);\n\n      if (missingHashes.length > 0) {\n        incompleteLocales.push({\n          locale,\n          missing: missingHashes.length,\n          total: allHashes.length,\n        });\n\n        // Log first few missing hashes for debugging\n        logger.debug(\n          `Missing hashes in ${locale}: ${missingHashes.slice(0, 5).join(\", \")}${\n            missingHashes.length > 5 ? \"...\" : \"\"\n          }`,\n        );\n      }\n    } catch (error) {\n      missingLocales.push(locale);\n      logger.debug(`Failed to read cache for ${locale}:`, error);\n    }\n  }\n\n  if (missingLocales.length > 0 || incompleteLocales.length > 0) {\n    const errorMsg = formatCacheValidationError(\n      missingLocales,\n      incompleteLocales,\n    );\n    logger.error(errorMsg);\n    process.exit(1);\n  }\n}\n\nfunction buildCacheStats(\n  config: LingoConfig,\n  metadata: MetadataSchema,\n): BuildTranslationResult[\"stats\"] {\n  const totalEntries = Object.keys(metadata.entries).length;\n  const stats: BuildTranslationResult[\"stats\"] = {};\n\n  // Include source locale if pluralization is enabled\n  const needsSourceLocale = config.pluralization?.enabled !== false;\n  const allLocales = needsSourceLocale\n    ? [config.sourceLocale, ...config.targetLocales]\n    : config.targetLocales;\n\n  for (const locale of allLocales) {\n    stats[locale] = {\n      total: totalEntries,\n      translated: totalEntries, // Assumed complete if validation passed\n      failed: 0,\n    };\n  }\n\n  return stats;\n}\n\nasync function copyStaticFiles(\n  config: LingoConfig,\n  publicOutputPath: string,\n  metadata: MetadataSchema,\n  cache: TranslationCache,\n): Promise<void> {\n  logger.info(`📦 Generating static translation files in ${publicOutputPath}`);\n\n  await fs.mkdir(publicOutputPath, { recursive: true });\n\n  const usedHashes = new Set(Object.keys(metadata.entries));\n  logger.info(`📊 Filtering translations to ${usedHashes.size} used hash(es)`);\n\n  // Include source locale if pluralization is enabled\n  const needsSourceLocale = config.pluralization?.enabled !== false;\n  const allLocales = needsSourceLocale\n    ? [config.sourceLocale, ...config.targetLocales]\n    : config.targetLocales;\n\n  for (const locale of allLocales) {\n    const publicFilePath = path.join(publicOutputPath, `${locale}.json`);\n\n    try {\n      const entries = await cache.get(locale, Array.from(usedHashes));\n      const outputData = dictionaryFrom(locale, entries);\n\n      await fs.writeFile(\n        publicFilePath,\n        JSON.stringify(outputData, null, 2),\n        \"utf-8\",\n      );\n\n      logger.info(\n        `✓ Generated ${locale}.json (${Object.keys(entries).length} translations)`,\n      );\n    } catch (error) {\n      logger.error(`❌ Failed to generate ${locale}.json:`, error);\n      process.exit(1);\n    }\n  }\n}\n\nfunction formatCacheValidationError(\n  missingLocales: string[],\n  incompleteLocales: Array<{\n    locale: LocaleCode;\n    missing: number;\n    total: number;\n  }>,\n): string {\n  let msg = \"❌ Cache validation failed in cache-only mode:\\n\\n\";\n\n  if (missingLocales.length > 0) {\n    msg += `  📁 Missing cache files:\\n`;\n    msg += missingLocales.map((locale) => `    - ${locale}.json`).join(\"\\n\");\n    msg += \"\\n\\n\";\n  }\n\n  if (incompleteLocales.length > 0) {\n    msg += `  📊 Incomplete cache:\\n`;\n    msg += incompleteLocales\n      .map(\n        (item) =>\n          `    - ${item.locale}: ${item.missing}/${item.total} translations missing`,\n      )\n      .join(\"\\n\");\n    msg += \"\\n\\n\";\n  }\n\n  msg += `  💡 To fix:\\n`;\n  msg += `    1. Set LINGO_BUILD_MODE=translate to generate translations\\n`;\n  msg += `    2. Commit the generated .lingo/cache/*.json files\\n`;\n  msg += `    3. Ensure translation API keys are available if generating translations`;\n\n  return msg;\n}\n\nfunction formatTranslationErrors(\n  errors: Array<{ locale: LocaleCode; error: string }>,\n): string {\n  let msg = \"❌ Translation generation failed:\\n\\n\";\n\n  msg += errors.map((err) => `  - ${err.locale}: ${err.error}`).join(\"\\n\");\n\n  msg += \"\\n\\n\";\n  msg += `  💡 Translation errors must be resolved in \"translate\" mode.\\n`;\n  msg += `     Check translation server logs for details.`;\n\n  return msg;\n}\n"],"mappings":"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"}

package/build/plugin/cleanup.cjs

@@ -0,0 +1,20 @@
+
+//#region src/plugin/cleanup.ts
+function registerCleanupOnCurrentProcess({ cleanup, asyncCleanup }) {
+	if (asyncCleanup) {
+		let shuttingDown = false;
+		async function performGracefulShutdown(code) {
+			if (shuttingDown) return;
+			shuttingDown = true;
+			await asyncCleanup?.();
+			process.exit(code);
+		}
+		process.on("SIGINT", () => performGracefulShutdown(0));
+		process.on("SIGTERM", () => performGracefulShutdown(143));
+		process.on("SIGBREAK", () => performGracefulShutdown(0));
+	}
+	if (cleanup) process.on("exit", () => cleanup());
+}
+
+//#endregion
+exports.registerCleanupOnCurrentProcess = registerCleanupOnCurrentProcess;

package/build/plugin/cleanup.mjs

@@ -0,0 +1,20 @@
+//#region src/plugin/cleanup.ts
+function registerCleanupOnCurrentProcess({ cleanup, asyncCleanup }) {
+	if (asyncCleanup) {
+		let shuttingDown = false;
+		async function performGracefulShutdown(code) {
+			if (shuttingDown) return;
+			shuttingDown = true;
+			await asyncCleanup?.();
+			process.exit(code);
+		}
+		process.on("SIGINT", () => performGracefulShutdown(0));
+		process.on("SIGTERM", () => performGracefulShutdown(143));
+		process.on("SIGBREAK", () => performGracefulShutdown(0));
+	}
+	if (cleanup) process.on("exit", () => cleanup());
+}
+
+//#endregion
+export { registerCleanupOnCurrentProcess };
+//# sourceMappingURL=cleanup.mjs.map

package/build/plugin/cleanup.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.mjs","names":[],"sources":["../../src/plugin/cleanup.ts"],"sourcesContent":["export function registerCleanupOnCurrentProcess({\n  cleanup,\n  asyncCleanup,\n}: {\n  cleanup?: () => void;\n  asyncCleanup?: () => Promise<void>;\n}) {\n  if (asyncCleanup) {\n    let shuttingDown = false;\n    async function performGracefulShutdown(code: number) {\n      if (shuttingDown) return;\n      shuttingDown = true;\n\n      await asyncCleanup?.();\n\n      process.exit(code);\n    }\n\n    process.on(\"SIGINT\", () => performGracefulShutdown(0));\n    process.on(\"SIGTERM\", () => performGracefulShutdown(143));\n    process.on(\"SIGBREAK\", () => performGracefulShutdown(0));\n  }\n\n  if (cleanup) {\n    process.on(\"exit\", () => cleanup());\n  }\n}\n"],"mappings":";AAAA,SAAgB,gCAAgC,EAC9C,SACA,gBAIC;AACD,KAAI,cAAc;EAChB,IAAI,eAAe;EACnB,eAAe,wBAAwB,MAAc;AACnD,OAAI,aAAc;AAClB,kBAAe;AAEf,SAAM,gBAAgB;AAEtB,WAAQ,KAAK,KAAK;;AAGpB,UAAQ,GAAG,gBAAgB,wBAAwB,EAAE,CAAC;AACtD,UAAQ,GAAG,iBAAiB,wBAAwB,IAAI,CAAC;AACzD,UAAQ,GAAG,kBAAkB,wBAAwB,EAAE,CAAC;;AAG1D,KAAI,QACF,SAAQ,GAAG,cAAc,SAAS,CAAC"}

package/build/plugin/next-compiler-loader.cjs

@@ -0,0 +1,41 @@
+const require_logger = require('../utils/logger.cjs');
+const require_manager = require('../metadata/manager.cjs');
+const require_index = require('./transform/index.cjs');
+
+//#region src/plugin/next-compiler-loader.ts
+/**
+* Turbopack/Webpack loader for automatic translation
+*
+* This loader transforms React components to inject translation calls automatically.
+*
+* For production builds, translations are generated after compilation completes
+* via Next.js's runAfterProductionCompile hook (see next.ts plugin).
+*/
+async function nextCompilerLoader(source) {
+	if (typeof this.async !== "function") throw new Error("This module must be run as a loader");
+	const callback = this.async();
+	try {
+		const config = this.getOptions();
+		const metadataManager = new require_manager.MetadataManager(config.metadataFilePath);
+		require_logger.logger.debug(`[Turbopack Loader] Processing: ${this.resourcePath}`);
+		const result = require_index.transformComponent({
+			code: source,
+			filePath: this.resourcePath,
+			config
+		});
+		if (!result.transformed) return callback(null, source);
+		if (result.newEntries && result.newEntries.length > 0) {
+			await metadataManager.saveMetadataWithEntries(result.newEntries);
+			require_logger.logger.debug(`[Turbopack Loader] Found ${result.newEntries.length} translatable text(s) in ${this.resourcePath}`);
+		}
+		const validMap = result.map && result.map.sources && Array.isArray(result.map.sources) && result.map.sources.every((s) => typeof s === "string") ? result.map : void 0;
+		callback(null, result.code, validMap);
+	} catch (error) {
+		require_logger.logger.error(`Compiler failed for ${this.resourcePath}:`);
+		require_logger.logger.error("Details:", error, typeof error === "object" && error && "message" in error ? error.message : error, error instanceof Error ? error.stack : void 0);
+		callback(error);
+	}
+}
+
+//#endregion
+module.exports = nextCompilerLoader;