@the-i18n-kit/cli 5.0.0 → 7.0.0

package/dist/detector-DtFY4qm3.js

@@ -0,0 +1,2189 @@
+import { i as toErrorMessage, n as FileIOError, t as ConfigError } from "./errors-coI1dhw1.js";
+import { i as log, n as loadProjectConfig } from "./project-config-C3ao4Uii.js";
+import { _ as readLocaleFile, a as atomicWrite, g as clearFileCacheEntry, h as clearFileCache, l as orderKeysPreserving, p as sortKeysDeep, r as writeLocaleFile, t as mutateLocaleFile, v as createReadCache } from "./json-writer-ek8yEI5R.js";
+import { n as clearPhpFileCacheEntry, r as readPhpLocaleFile, t as clearPhpFileCache } from "./php-reader-DRpcRVzv.js";
+import { createRequire } from "node:module";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { readFile, readdir, realpath } from "node:fs/promises";
+import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { parseAllDocuments, stringify } from "yaml";
+import { z } from "zod";
+import { fileURLToPath } from "node:url";
+import { glob } from "tinyglobby";
+//#region src/io/php-writer.ts
+async function writePhpLocaleFile(filePath, data, options = {}) {
+	const { quoteStyle = "double", indent = "    ", sortKeys = true } = options;
+	try {
+		await atomicWrite(filePath, serializePhpArray(sortKeys ? sortKeysDeep(data) : data, quoteStyle, indent), () => clearPhpFileCacheEntry(filePath));
+	} catch (error) {
+		if (error instanceof FileIOError) throw error;
+		throw new FileIOError(`Failed to write PHP locale file: ${filePath}: ${toErrorMessage(error)}`, filePath);
+	}
+}
+function serializePhpArray(data, quoteStyle, indent) {
+	const q = quoteStyle === "single" ? "'" : "\"";
+	const lines = [
+		"<?php",
+		"",
+		"return ["
+	];
+	renderEntries(data, lines, q, indent, 1);
+	lines.push("];", "");
+	return lines.join("\n");
+}
+function renderEntries(obj, lines, q, indent, depth) {
+	const prefix = indent.repeat(depth);
+	const entries = Object.entries(obj);
+	for (const [key, value] of entries) {
+		const keyPart = `${prefix}${q}${escapePhpString(key, q)}${q}`;
+		if (value === null) lines.push(`${keyPart} => null,`);
+		else if (typeof value === "boolean") lines.push(`${keyPart} => ${value ? "true" : "false"},`);
+		else if (typeof value === "number") lines.push(`${keyPart} => ${value},`);
+		else if (Array.isArray(value)) {
+			lines.push(`${keyPart} => [`);
+			renderArray(value, lines, q, indent, depth + 1);
+			lines.push(`${prefix}],`);
+		} else if (typeof value === "object") {
+			lines.push(`${keyPart} => [`);
+			renderEntries(value, lines, q, indent, depth + 1);
+			lines.push(`${prefix}],`);
+		} else {
+			const escapedValue = escapePhpString(String(value), q);
+			lines.push(`${keyPart} => ${q}${escapedValue}${q},`);
+		}
+	}
+}
+function escapePhpString(str, quote) {
+	if (quote === "'") return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+	return str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$");
+}
+function renderArray(arr, lines, q, indent, depth) {
+	const prefix = indent.repeat(depth);
+	for (const value of arr) if (value === null) lines.push(`${prefix}null,`);
+	else if (typeof value === "boolean") lines.push(`${prefix}${value ? "true" : "false"},`);
+	else if (typeof value === "number") lines.push(`${prefix}${value},`);
+	else if (Array.isArray(value)) {
+		lines.push(`${prefix}[`);
+		renderArray(value, lines, q, indent, depth + 1);
+		lines.push(`${prefix}],`);
+	} else if (typeof value === "object") {
+		lines.push(`${prefix}[`);
+		renderEntries(value, lines, q, indent, depth + 1);
+		lines.push(`${prefix}],`);
+	} else {
+		const escaped = escapePhpString(String(value), q);
+		lines.push(`${prefix}${q}${escaped}${q},`);
+	}
+}
+function detectPhpStyle(content) {
+	const keyPattern = /(['"])([^'"]+)\1\s*=>/g;
+	let singleCount = 0;
+	let doubleCount = 0;
+	let match;
+	while ((match = keyPattern.exec(content)) !== null) if (match[1] === "'") singleCount++;
+	else doubleCount++;
+	return {
+		quoteStyle: singleCount > doubleCount ? "single" : "double",
+		indent: content.match(/^([ \t]+)['"]/m)?.[1] ?? "    "
+	};
+}
+/**
+* Read, mutate, and write back a single PHP locale file while preserving its
+* existing style (quote style + indentation, via detectPhpStyle) and key
+* order: existing keys keep their on-disk order; keys added by the mutation
+* are inserted in sorted position among their siblings.
+*/
+async function mutatePhpLocaleFile(filePath, mutate) {
+	const { readPhpLocaleFile } = await import("./php-reader-BGx6Ii2d.js");
+	const data = await readPhpLocaleFile(filePath);
+	const { quoteStyle, indent } = detectPhpStyle(await readFile(filePath, "utf-8"));
+	const reference = structuredClone(data);
+	mutate(data);
+	await writePhpLocaleFile(filePath, orderKeysPreserving(data, reference), {
+		quoteStyle,
+		indent,
+		sortKeys: false
+	});
+}
+//#endregion
+//#region src/io/yaml-reader.ts
+/**
+* Parse a YAML locale file into plain data.
+*
+* A locale file is one mapping, so a stream of several documents is refused by
+* name rather than silently reduced to its first one. Parse errors are
+* collected on the document rather than thrown, so the first one is raised
+* here to reach the same wrapping the JSON reader gets.
+*/
+function parseYaml(content) {
+	const documents = parseAllDocuments(content);
+	if (documents.length > 1) throw new SyntaxError(`YAML file holds ${documents.length} documents (separated by '---') — a locale file must hold exactly one`);
+	const document = documents[0];
+	if (!document) return null;
+	const error = document.errors[0];
+	if (error) throw new SyntaxError(error.message);
+	return document.toJS();
+}
+const { read: readYamlLocaleFile, clear: clearYamlFileCache, clearEntry: clearYamlFileCacheEntry } = createReadCache(parseYaml, "YAML", (parsed, filePath) => {
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new FileIOError(`YAML file must contain a mapping: ${filePath}`, filePath, "INVALID_YAML");
+});
+//#endregion
+//#region src/io/yaml-writer.ts
+/**
+* Fixed rather than detected from the file being written: YAML has one legal
+* indent character, and `lineWidth: 0` keeps long UI strings on a single line.
+* Folded ones re-read as the same string, but every wrap point moves as soon
+* as a word changes, which turns a one-word edit into a multi-line diff.
+*/
+const STRINGIFY_OPTIONS = {
+	indent: 2,
+	lineWidth: 0
+};
+/**
+* Comments in an existing file do not survive a write: the file is
+* re-serialized from the parsed values, not patched into the document tree
+* that carries them. Keep notes for translators in the kit config
+* (`localeNotes`) rather than in the locale files it rewrites.
+*/
+async function writeYamlLocaleFile(filePath, data, options = {}) {
+	const { sortKeys = true } = options;
+	try {
+		await atomicWrite(filePath, stringify(sortKeys ? sortKeysDeep(data) : data, STRINGIFY_OPTIONS), () => clearYamlFileCacheEntry(filePath));
+	} catch (error) {
+		if (error instanceof FileIOError) throw error;
+		throw new FileIOError(`Failed to write YAML locale file: ${filePath}: ${toErrorMessage(error)}`, filePath);
+	}
+}
+/**
+* Read, mutate and write back a single YAML locale file, preserving key order:
+* existing keys keep their on-disk order and keys added by the mutation are
+* inserted in sorted position among their siblings.
+*/
+async function mutateYamlLocaleFile(filePath, mutate) {
+	const data = await readYamlLocaleFile(filePath);
+	const reference = structuredClone(data);
+	mutate(data);
+	await writeYamlLocaleFile(filePath, orderKeysPreserving(data, reference), { sortKeys: false });
+}
+//#endregion
+//#region src/io/formats.ts
+/**
+* One registry for everything that differs between locale file formats.
+*
+* The readers and writers used to be reachable only through
+* `if (format === 'php-array')` branches scattered across locale IO, format
+* detection, the read operations and the scaffolder, so every new format meant
+* finding all of them again. A format now declares its extensions, its IO
+* functions and the two layout facts those callers used the format id to
+* guess, and they dispatch through `getFormat` / `formatForFile` instead of
+* comparing strings.
+*/
+const formats = /* @__PURE__ */ new Map();
+const byExtension = /* @__PURE__ */ new Map();
+function registerFormat(format) {
+	formats.set(format.id, format);
+	for (const extension of format.extensions) byExtension.set(extension.toLowerCase(), format);
+}
+/**
+* The format a config's `localeFileFormat` names. Undefined resolves to JSON,
+* which is what an adapter that declares nothing has always meant.
+*/
+function getFormat(id) {
+	const format = formats.get(id ?? "json");
+	if (!format) throw new ConfigError(`Unknown locale file format: ${id}. Known formats: ${[...formats.keys()].join(", ")}`);
+	return format;
+}
+/** The format that owns a file's extension. */
+function formatForFile(filePath) {
+	const ext = extname(filePath).toLowerCase();
+	const format = byExtension.get(ext);
+	if (!format) throw new FileIOError(`Unsupported locale file format: ${ext}`, filePath);
+	return format;
+}
+/**
+* Guess the format of a locale directory from the files in it — flat
+* `en.json` / `en.php` / `en.yaml` first, then a directory per locale. Returns
+* null when nothing recognizable is there, leaving the default to the caller. A
+* directory holding more than one format resolves to whichever has the most
+* files and warns, because the format that loses is invisible from then on.
+*/
+async function detectFormatInDir(localeDir) {
+	let entries;
+	try {
+		entries = await readdir(localeDir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	const flat = decide(countFormats(entries.filter((e) => e.isFile()).map((e) => e.name)), localeDir);
+	if (flat) return flat;
+	const nested = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const subFiles = await readdir(join(localeDir, entry.name)).catch(() => []);
+		for (const [id, count] of countFormats(subFiles)) nested.set(id, (nested.get(id) ?? 0) + count);
+	}
+	return decide(nested, localeDir);
+}
+function countFormats(fileNames) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const name of fileNames) {
+		const format = byExtension.get(extname(name).toLowerCase());
+		if (!format) continue;
+		counts.set(format.id, (counts.get(format.id) ?? 0) + 1);
+	}
+	return counts;
+}
+function decide(counts, localeDir) {
+	let winner = null;
+	let best = 0;
+	for (const id of formats.keys()) {
+		const count = counts.get(id) ?? 0;
+		if (count > best) {
+			winner = id;
+			best = count;
+		}
+	}
+	if (!winner) return null;
+	if (counts.size > 1) {
+		const seen = [...counts.entries()].map(([id, count]) => `${id} (${count})`).join(", ");
+		log.warn(`Locale directory ${localeDir} mixes file formats: ${seen}. Reading and writing it as '${winner}' — files in the other formats are ignored. Keep one format per locale directory.`);
+	}
+	return winner;
+}
+registerFormat({
+	id: "json",
+	extensions: [".json"],
+	defaultLayout: "flat",
+	flatFileFromDisk: false,
+	read: readLocaleFile,
+	write: (filePath, data, options) => writeLocaleFile(filePath, data, options),
+	mutate: mutateLocaleFile,
+	clearCache: clearFileCache,
+	clearCacheEntry: clearFileCacheEntry
+});
+registerFormat({
+	id: "php-array",
+	extensions: [".php"],
+	defaultLayout: "namespaced",
+	flatFileFromDisk: true,
+	read: readPhpLocaleFile,
+	write: (filePath, data, options) => writePhpLocaleFile(filePath, data, options),
+	mutate: mutatePhpLocaleFile,
+	clearCache: clearPhpFileCache,
+	clearCacheEntry: clearPhpFileCacheEntry
+});
+registerFormat({
+	id: "yaml",
+	extensions: [".yaml", ".yml"],
+	defaultLayout: "flat",
+	flatFileFromDisk: false,
+	read: readYamlLocaleFile,
+	write: (filePath, data, options) => writeYamlLocaleFile(filePath, data, options),
+	mutate: mutateYamlLocaleFile,
+	clearCache: clearYamlFileCache,
+	clearCacheEntry: clearYamlFileCacheEntry
+});
+//#endregion
+//#region src/adapters/registry.ts
+const adapters = [];
+function registerAdapter(adapter) {
+	adapters.push(adapter);
+}
+/**
+* Names that no longer have an adapter of their own, mapped to the one that
+* resolves those projects now. Kept so a config written against a retired
+* adapter keeps validating and resolving instead of failing on an unknown
+* hint, and warned about because the replacement needs more from the config
+* than the retired adapter did.
+*/
+const RETIRED_HINTS = { vue: {
+	replacement: "generic",
+	warning: "vue projects resolve through the generic adapter; declare localeDirs"
+} };
+function resolveHint(hint) {
+	const retired = RETIRED_HINTS[hint];
+	if (!retired) return hint;
+	log.warn(`framework: "${hint}" — ${retired.warning}`);
+	return retired.replacement;
+}
+/**
+* Detect the framework and report how confidently. `detectFramework` returns
+* only the winner; `init` needs the score to tell a user why Nuxt was chosen
+* over generic, and a bare directory needs to be distinguishable from a
+* confident match rather than surfacing as a thrown error.
+*/
+async function detectFrameworkMatch(projectDir, hint) {
+	if (adapters.length === 0) throw new ConfigError("No framework adapters registered.");
+	if (hint) {
+		const name = resolveHint(hint);
+		const match = adapters.find((a) => a.name === name);
+		if (!match) return void 0;
+		return {
+			adapter: match,
+			confidence: 0,
+			runnersUp: []
+		};
+	}
+	const ranked = (await Promise.all(adapters.map(async (adapter) => {
+		try {
+			return {
+				adapter,
+				confidence: await adapter.detect(projectDir)
+			};
+		} catch (error) {
+			log.warn(`Adapter '${adapter.name}' detection failed: ${toErrorMessage(error)}`);
+			return {
+				adapter,
+				confidence: 0
+			};
+		}
+	}))).filter((s) => s.confidence > 0).sort((a, b) => b.confidence - a.confidence);
+	const [best] = ranked;
+	if (!best) return void 0;
+	return {
+		adapter: best.adapter,
+		confidence: best.confidence,
+		runnersUp: ranked.slice(1).map((s) => ({
+			name: s.adapter.name,
+			confidence: s.confidence
+		}))
+	};
+}
+async function detectFramework(projectDir, hint) {
+	const match = await detectFrameworkMatch(projectDir, hint);
+	if (match) return match.adapter;
+	if (hint) throw new ConfigError(`Framework hint "${hint}" does not match any registered adapter. Available: ${adapters.map((a) => a.name).join(", ")}`);
+	throw new ConfigError(`No framework detected for ${projectDir}. Registered adapters: ${adapters.map((a) => a.name).join(", ")}. Declare localeDirs and defaultLocale to resolve the project through the generic adapter.`);
+}
+//#endregion
+//#region src/config/paths.ts
+/**
+* Directory helpers every framework shares: identifying a project directory,
+* and naming a layer after where it sits. Finding the apps in a project is a
+* framework's own business and lives with its adapter.
+*/
+function canonicalPath(dir) {
+	try {
+		return realpathSync(resolve(dir));
+	} catch {
+		return resolve(dir);
+	}
+}
+/**
+* Derive a human-friendly layer name from its root directory.
+* Uses the discovery root as the reference point for naming.
+*
+* When `usedNames` is provided, disambiguates collisions by progressively
+* including parent path segments (e.g., `admin` → `apps/admin`).
+*/
+function deriveLayerName(layerRootDir, discoveryRoot, usedNames) {
+	const rel = relative(discoveryRoot, layerRootDir);
+	if (rel === "" || rel === ".") return "root";
+	const posixRel = rel.replace(/\\/g, "/");
+	if (!posixRel.startsWith("..")) {
+		const segments = posixRel.split("/");
+		let candidate = segments.pop() ?? posixRel;
+		if (usedNames) for (let i = segments.length - 1; i >= 0; i--) {
+			if (!usedNames.has(candidate)) break;
+			candidate = `${segments[i]}/${candidate}`;
+		}
+		return candidate;
+	}
+	const parts = layerRootDir.replace(/\\/g, "/").split("/");
+	let candidate = parts.pop() ?? layerRootDir;
+	if (usedNames) for (let i = parts.length - 1; i >= 0; i--) {
+		if (!usedNames.has(candidate)) break;
+		candidate = `${parts[i]}/${candidate}`;
+	}
+	return candidate;
+}
+//#endregion
+//#region src/config/locale-override.ts
+/**
+* Apply the optional `locales` override from `.i18n-mcp.json` on top of the
+* locales auto-discovered by a framework adapter.
+*
+* Semantics:
+* - If `projectLocales` is unset/empty → return `discovered` unchanged.
+* - Else → restrict to the configured codes, preserving the order from
+*   `projectLocales` and keeping the metadata (file, language, name) from
+*   the discovered entries. Configured codes with no matching discovered
+*   entry get a minimal `{code, language: code}` fallback and a warning.
+*/
+function applyLocaleOverride(discovered, projectLocales) {
+	if (!projectLocales || projectLocales.length === 0) return discovered;
+	const byCode = new Map(discovered.map((l) => [l.code, l]));
+	const missing = [];
+	const result = projectLocales.map((code) => {
+		const found = byCode.get(code);
+		if (found) return found;
+		missing.push(code);
+		return {
+			code,
+			language: code
+		};
+	});
+	if (missing.length > 0) log.warn(`Configured locales not found in framework auto-detection: ${missing.join(", ")}. Translations for these codes may fail to write — make sure the locale files exist.`);
+	const dropped = discovered.filter((l) => !projectLocales.includes(l.code));
+	if (dropped.length > 0) log.debug(`Locale override active: dropped ${dropped.length} auto-detected locale(s) (${dropped.map((l) => l.code).join(", ")})`);
+	return result;
+}
+//#endregion
+//#region src/config/fallback-locale.ts
+/**
+* Normalise `@nuxtjs/i18n`'s `fallbackLocale` — a string, an array, or a
+* per-locale map — into the single map shape the rest of the CLI reads.
+*
+* Shared by both paths on purpose. The Nuxt module publishes this value exactly
+* as Nuxt resolved it rather than normalising it itself: two implementations of
+* the same normalisation, in two packages that do not depend on each other, is
+* precisely the drift the module exists to remove.
+*/
+function normalizeFallbackLocale(fallback, defaultLocale) {
+	if (typeof fallback === "string") return { default: [fallback] };
+	if (Array.isArray(fallback)) return { default: fallback.map(String) };
+	if (fallback && typeof fallback === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(fallback)) if (Array.isArray(value)) result[key] = value.map(String);
+		else if (typeof value === "string") result[key] = [value];
+		return result;
+	}
+	return { default: [defaultLocale] };
+}
+//#endregion
+//#region src/adapters/nuxt/discovery.ts
+const NUXT_CONFIG_FILES$1 = [
+	"nuxt.config.ts",
+	"nuxt.config.js",
+	"nuxt.config.mjs"
+];
+const SKIP_DIRS$1 = new Set([
+	"node_modules",
+	".nuxt",
+	".output",
+	".git",
+	"dist",
+	".cache"
+]);
+const MAX_DISCOVERY_DEPTH = 4;
+function findNuxtConfig(dir) {
+	for (const name of NUXT_CONFIG_FILES$1) if (existsSync(resolve(dir, name))) return name;
+	return null;
+}
+async function hasI18nConfig(configPath) {
+	try {
+		const content = await readFile(configPath, "utf-8");
+		return /\bi18n\b/.test(content);
+	} catch {
+		return false;
+	}
+}
+/**
+* Discover all Nuxt apps with i18n configuration under a root directory.
+* Scans recursively up to MAX_DISCOVERY_DEPTH levels deep,
+* skipping common non-project directories.
+*
+* Returns sorted absolute paths to directories that:
+* 1. Contain a nuxt.config.{ts,js,mjs} file
+* 2. The config file references i18n
+*/
+async function discoverNuxtApps(rootDir) {
+	const apps = [];
+	await scanForApps(rootDir, 0, apps, true);
+	const root = resolve(rootDir);
+	apps.sort((a, b) => relative(root, a).localeCompare(relative(root, b)));
+	return apps;
+}
+async function scanForApps(dir, depth, results, isRoot = false) {
+	if (depth > MAX_DISCOVERY_DEPTH) return;
+	const configFile = findNuxtConfig(dir);
+	if (configFile) {
+		if (await hasI18nConfig(resolve(dir, configFile))) results.push(dir);
+		if (!isRoot) return;
+	}
+	let entries;
+	try {
+		entries = await readdir(dir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (entry.startsWith(".") || SKIP_DIRS$1.has(entry)) continue;
+		const childDir = resolve(dir, entry);
+		try {
+			if (!statSync(childDir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		await scanForApps(childDir, depth + 1, results);
+	}
+}
+//#endregion
+//#region src/adapters/nuxt/kit-loader.ts
+/** Import `id` resolved against the project's node_modules rather than our own. */
+async function importModuleFrom(id, rootDir) {
+	const { createRequire } = await import("node:module");
+	return import(createRequire(rootDir + "/").resolve(id));
+}
+/**
+* Load @nuxt/kit from the project's own node_modules.
+* Falls back to trying common Nuxt package names.
+*/
+async function loadKit(rootDir) {
+	try {
+		const kit = await importModuleFrom("@nuxt/kit", rootDir);
+		log.debug(`Loaded @nuxt/kit from project: ${rootDir}`);
+		return kit;
+	} catch (e) {
+		if (String(e).includes("Cannot find module '@nuxt/kit'")) throw new Error("@nuxt/kit is required for Nuxt projects but was not found. Install it with: npm install --save-dev @nuxt/kit\nLaravel projects do not need @nuxt/kit — if this is a Laravel project, check that your .i18n-mcp.json has \"framework\": \"laravel\" or that your project structure is detected correctly.");
+		throw e;
+	}
+}
+//#endregion
+//#region src/adapters/nuxt/layer-dedup.ts
+function isAncestorOf(ancestorDir, childPath) {
+	const normalized = ancestorDir.endsWith(sep) ? ancestorDir : ancestorDir + sep;
+	return childPath.startsWith(normalized) || childPath === ancestorDir;
+}
+function ancestorDepth(ancestorDir, childPath) {
+	if (!isAncestorOf(ancestorDir, childPath)) return -1;
+	return ancestorDir.split(sep).filter(Boolean).length;
+}
+function resolveLayerOwnership(existing, incoming, localeDirPath) {
+	const existingIsAncestor = isAncestorOf(existing.layerRootDir, localeDirPath);
+	const incomingIsAncestor = isAncestorOf(incoming.layerRootDir, localeDirPath);
+	if (existingIsAncestor && !incomingIsAncestor) return {
+		owner: existing.layer,
+		alias: incoming.layer
+	};
+	if (incomingIsAncestor && !existingIsAncestor) return {
+		owner: incoming.layer,
+		alias: existing.layer
+	};
+	if (existingIsAncestor && incomingIsAncestor) {
+		const existingDepth = ancestorDepth(existing.layerRootDir, localeDirPath);
+		if (ancestorDepth(incoming.layerRootDir, localeDirPath) > existingDepth) return {
+			owner: incoming.layer,
+			alias: existing.layer
+		};
+		return {
+			owner: existing.layer,
+			alias: incoming.layer
+		};
+	}
+	return {
+		owner: existing.layer,
+		alias: incoming.layer
+	};
+}
+/**
+* Claim a locale directory for a layer, deduplicating by real path.
+*
+* Mutates `dirs` and `claims`:
+* - First claim for `realPath`: the incoming dir is pushed and recorded as owner.
+* - Same path already claimed and the incoming layer wins ownership
+*   (see `resolveLayerOwnership`): the incoming dir replaces the previous
+*   owner in place, and the previous owner is re-pushed demoted to an alias.
+* - Same path already claimed and the existing layer keeps ownership: the
+*   incoming dir is pushed as an alias of the owner (unless it *is* the owner).
+* - If the recorded owner cannot be found as a non-alias entry (it was itself
+*   demoted to an alias by an earlier takeover on another path), the incoming
+*   dir is still pushed as an alias — a claim never silently drops a dir.
+*/
+function claimLocaleDir(dirs, claims, incoming, realPath) {
+	const existing = claims.get(realPath);
+	if (!existing) {
+		claims.set(realPath, {
+			layer: incoming.layer,
+			layerRootDir: incoming.layerRootDir
+		});
+		dirs.push({ ...incoming });
+		return;
+	}
+	const { owner, alias } = resolveLayerOwnership({
+		layer: existing.layer,
+		layerRootDir: existing.layerRootDir
+	}, {
+		layer: incoming.layer,
+		layerRootDir: incoming.layerRootDir
+	}, realPath);
+	if (owner !== existing.layer) {
+		const ownerIndex = dirs.findIndex((d) => d.layer === existing.layer && !d.aliasOf);
+		const previousOwner = ownerIndex !== -1 ? dirs[ownerIndex] : void 0;
+		if (previousOwner) {
+			const promoted = { ...incoming };
+			delete promoted.aliasOf;
+			dirs[ownerIndex] = promoted;
+			dirs.push({
+				...previousOwner,
+				aliasOf: owner
+			});
+			claims.set(realPath, {
+				layer: incoming.layer,
+				layerRootDir: incoming.layerRootDir
+			});
+			log.debug(`Layer '${alias}' is alias of '${owner}' (ancestor-based ownership, same path: ${incoming.path})`);
+		} else {
+			dirs.push({
+				...incoming,
+				aliasOf: existing.layer
+			});
+			log.debug(`Layer '${incoming.layer}' is alias of '${existing.layer}' (owner already aliased, same path: ${incoming.path})`);
+		}
+	} else if (incoming.layer !== existing.layer) {
+		dirs.push({
+			...incoming,
+			aliasOf: owner
+		});
+		log.debug(`Layer '${alias}' is alias of '${owner}' (same path: ${incoming.path})`);
+	}
+}
+//#endregion
+//#region src/adapters/nuxt/artifact.ts
+/** Where @the-i18n-kit/nuxt publishes what Nuxt resolved, relative to an app. */
+const ARTIFACT_PATH = ".nuxt/i18n-kit.json";
+const localeSchema = z.object({
+	code: z.string().min(1),
+	language: z.string(),
+	file: z.string().min(1),
+	name: z.string().optional()
+});
+const layerSchema = z.object({
+	rootDir: z.string().min(1),
+	localeDir: z.string().min(1).optional()
+});
+const artifactSchema = z.object({
+	version: z.literal(1),
+	generator: z.string(),
+	appDir: z.string().min(1),
+	defaultLocale: z.string().min(1),
+	fallbackLocale: z.union([
+		z.string(),
+		z.array(z.string()),
+		z.record(z.string(), z.union([z.string(), z.array(z.string())])),
+		z.null()
+	]),
+	localeFileFormat: z.literal("json"),
+	locales: z.array(localeSchema).min(1),
+	layers: z.array(layerSchema).min(1)
+});
+/**
+* Read an app's artifact, or null when there isn't a usable one.
+*
+* Never throws: every failure here — absent, malformed, a version this CLI
+* does not know, or older than the config it claims to describe — means
+* falling back to loading the app through Nuxt, which is what happens today
+* anyway. A module that cannot be trusted must not be able to break a project
+* that worked without it.
+*/
+async function readArtifact(appDir) {
+	const path = resolve(appDir, ARTIFACT_PATH);
+	if (!existsSync(path)) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(await readFile(path, "utf-8"));
+	} catch (error) {
+		log.warn(`Ignoring ${path}: ${error instanceof Error ? error.message : String(error)}`);
+		return null;
+	}
+	const result = artifactSchema.safeParse(parsed);
+	if (!result.success) {
+		const [issue] = result.error.issues;
+		const where = issue?.path.join(".") || "(root)";
+		log.warn(`Ignoring ${path}: not a shape this CLI understands (${where}: ${issue?.message}).`);
+		return null;
+	}
+	const changed = staleAgainst(result.data, path);
+	if (changed) {
+		log.warn(`Ignoring ${path}: ${changed} has changed since it was generated. Run \`nuxt prepare\` to refresh it — falling back to loading the app.`);
+		return null;
+	}
+	log.info(`Using the layer graph published by ${result.data.generator}`);
+	return result.data;
+}
+/**
+* An artifact older than any config it describes is a lie about the current
+* project, and a quiet one. Cheaper to distrust it than to explain later why a
+* renamed locale never took effect.
+*
+* Returns the config that outdates it, for the message; undefined when the
+* artifact is current, when no config can be found, or when a stat fails —
+* unreadable timestamps are not evidence of staleness.
+*/
+function staleAgainst(artifact, artifactPath) {
+	let artifactMtime;
+	try {
+		artifactMtime = statSync(artifactPath).mtimeMs;
+	} catch {
+		return;
+	}
+	const dirs = [artifact.appDir, ...artifact.layers.map((l) => l.rootDir)];
+	for (const dir of new Set(dirs)) {
+		const configFile = findNuxtConfig(dir);
+		if (!configFile) continue;
+		const configPath = resolve(dir, configFile);
+		try {
+			if (statSync(configPath).mtimeMs > artifactMtime) return configPath;
+		} catch {
+			continue;
+		}
+	}
+}
+/**
+* Turn one app's artifact into the config shape every command consumes.
+*
+* Layer *names* are derived here rather than read from the artifact: they
+* depend on the directory the CLI was pointed at, which the module cannot
+* know. Deriving them in one place is what keeps the artifact path and the
+* fallback path producing the same names for the same project.
+*/
+async function artifactToConfig(artifact, appDir, discoveryRoot, projectConfig) {
+	const localeDirs = [];
+	const claimed = /* @__PURE__ */ new Map();
+	const usedLayerNames = /* @__PURE__ */ new Set();
+	for (const layer of artifact.layers) {
+		const layerName = deriveLayerName(layer.rootDir, discoveryRoot, usedLayerNames);
+		usedLayerNames.add(layerName);
+		if (!layer.localeDir) continue;
+		const realDir = await realpath(layer.localeDir).catch(() => layer.localeDir);
+		claimLocaleDir(localeDirs, claimed, {
+			path: layer.localeDir,
+			layer: layerName,
+			layerRootDir: layer.rootDir
+		}, realDir);
+	}
+	const layerRootDirs = [...new Set(artifact.layers.map((l) => l.rootDir))];
+	if (layerRootDirs.length === 0) layerRootDirs.push(appDir);
+	const namesForApp = /* @__PURE__ */ new Set();
+	const app = {
+		name: deriveLayerName(appDir, discoveryRoot, /* @__PURE__ */ new Set()),
+		rootDir: appDir,
+		layers: artifact.layers.map((l) => deriveLayerName(l.rootDir, discoveryRoot, namesForApp))
+	};
+	const locales = artifact.locales.map((l) => ({
+		code: l.code,
+		language: l.language,
+		file: l.file,
+		...l.name === void 0 ? {} : { name: l.name }
+	}));
+	return {
+		rootDir: appDir,
+		defaultLocale: artifact.defaultLocale,
+		fallbackLocale: normalizeFallbackLocale(artifact.fallbackLocale, artifact.defaultLocale),
+		locales: applyLocaleOverride(locales, projectConfig?.locales),
+		localeDirs,
+		layerRootDirs,
+		projectConfig: projectConfig ?? void 0,
+		apps: [app]
+	};
+}
+//#endregion
+//#region src/adapters/nuxt/merge-apps.ts
+/**
+* Folds several Nuxt apps into one project config.
+*
+* A monorepo's apps overlap: they extend the same root layer, sometimes alias
+* each other's locale directories, and each reports the full locale table its
+* layers declare. Merging them is therefore four separate reconciliations —
+* directories claimed once by real path, locales deduplicated by code, layer
+* roots kept unique, and app→layer edges rewritten to whatever the directory
+* ended up being called. Keeping that state in one place stops the caller from
+* having to hold all four in its head at once.
+*/
+var AppMerger = class {
+	localeDirs = [];
+	locales = [];
+	layerRootDirs = [];
+	apps = [];
+	defaultLocale = "en";
+	fallbackLocale = { default: ["en"] };
+	claimedPaths = /* @__PURE__ */ new Map();
+	seenLocaleCodes = /* @__PURE__ */ new Set();
+	usedLayerNames = /* @__PURE__ */ new Set();
+	async add(appConfig, discoveryRoot) {
+		if (this.localeDirs.length === 0) {
+			this.defaultLocale = appConfig.defaultLocale;
+			this.fallbackLocale = appConfig.fallbackLocale;
+		}
+		const renamedLayers = await this.claimDirs(appConfig, discoveryRoot);
+		this.collectLocales(appConfig);
+		this.collectLayerRoots(appConfig);
+		this.collectApps(appConfig, renamedLayers);
+	}
+	toConfig(discoveryRoot, projectConfig, locales) {
+		return {
+			rootDir: discoveryRoot,
+			defaultLocale: this.defaultLocale,
+			fallbackLocale: this.fallbackLocale,
+			locales,
+			localeDirs: this.localeDirs,
+			layerRootDirs: this.layerRootDirs,
+			projectConfig,
+			apps: this.apps
+		};
+	}
+	/**
+	* Claim each of this app's locale directories, renaming a layer whose name is
+	* already taken by a different directory. Returns the renames, because the
+	* app's own layer list still refers to the old names.
+	*/
+	async claimDirs(appConfig, discoveryRoot) {
+		const renamed = /* @__PURE__ */ new Map();
+		for (const dir of appConfig.localeDirs) {
+			const realPath = await realpath(dir.path).catch(() => dir.path);
+			let claim = dir;
+			if (!this.claimedPaths.has(realPath)) {
+				const layer = this.uniqueLayerName(dir, discoveryRoot);
+				if (layer !== dir.layer) renamed.set(dir.layer, layer);
+				this.usedLayerNames.add(layer);
+				claim = {
+					...dir,
+					layer
+				};
+			}
+			claimLocaleDir(this.localeDirs, this.claimedPaths, claim, realPath);
+		}
+		return renamed;
+	}
+	uniqueLayerName(dir, discoveryRoot) {
+		if (!this.usedLayerNames.has(dir.layer)) return dir.layer;
+		return deriveLayerName(dir.layerRootDir, discoveryRoot, this.usedLayerNames);
+	}
+	collectLocales(appConfig) {
+		for (const locale of appConfig.locales) {
+			if (this.seenLocaleCodes.has(locale.code)) continue;
+			this.seenLocaleCodes.add(locale.code);
+			this.locales.push(locale);
+		}
+	}
+	collectLayerRoots(appConfig) {
+		for (const rootDir of appConfig.layerRootDirs) if (!this.layerRootDirs.includes(rootDir)) this.layerRootDirs.push(rootDir);
+	}
+	collectApps(appConfig, renamedLayers) {
+		for (const app of appConfig.apps) this.apps.push({
+			...app,
+			layers: app.layers.map((name) => renamedLayers.get(name) ?? name)
+		});
+	}
+};
+//#endregion
+//#region src/adapters/nuxt/index.ts
+var NuxtAdapter = class {
+	name = "nuxt";
+	label = "Nuxt";
+	localeFileFormat = "json";
+	async detect(projectDir) {
+		const configFile = findNuxtConfig(projectDir);
+		if (configFile) {
+			try {
+				const content = await readFile(resolve(projectDir, configFile), "utf-8");
+				if (/\bi18n\b/.test(content)) return 2;
+			} catch {}
+			return (await discoverNuxtApps(projectDir)).length > 0 ? 2 : 1;
+		}
+		return (await discoverNuxtApps(projectDir)).length > 0 ? 2 : 0;
+	}
+	async resolve(projectDir, projectConfig) {
+		const appDirs = await discoverNuxtApps(projectDir);
+		if (findNuxtConfig(projectDir) && !appDirs.includes(projectDir)) appDirs.unshift(projectDir);
+		if (appDirs.length === 0) throw new ConfigError(`No Nuxt apps with i18n configuration found under ${projectDir}. Make sure your Nuxt apps have a nuxt.config.ts with i18n configured.`);
+		const [soleAppDir] = appDirs;
+		if (appDirs.length === 1 && soleAppDir !== void 0) {
+			const config = await loadApp(soleAppDir, projectDir, projectConfig);
+			if (soleAppDir !== projectDir) {
+				config.rootDir = projectDir;
+				const rootApp = config.apps[0];
+				if (rootApp) rootApp.rootDir = projectDir;
+			}
+			log.info(`Detected ${config.locales.length} locales, ${config.localeDirs.length} locale directories`);
+			return config;
+		}
+		log.info(`Discovered ${appDirs.length} Nuxt app(s) with i18n: ${appDirs.map((d) => relative(projectDir, d) || ".").join(", ")}`);
+		const config = await loadAndMergeApps(appDirs, projectDir, projectConfig);
+		log.info(`Detected ${config.locales.length} locales, ${config.localeDirs.length} locale directories from ${appDirs.length} app(s)`);
+		return config;
+	}
+};
+/**
+* One app's config, preferring what @the-i18n-kit/nuxt published from inside
+* the build over reconstructing it from outside. The artifact is additive: any
+* reason not to trust it falls through to loading the app exactly as before,
+* so a project without the module — or with a stale one — behaves as it always
+* has.
+*/
+async function loadApp(appDir, discoveryRoot, projectConfig) {
+	const artifact = await readArtifact(appDir);
+	if (!artifact) return loadSingleApp(appDir, discoveryRoot, projectConfig);
+	const config = await artifactToConfig(artifact, appDir, discoveryRoot, projectConfig);
+	if (config.localeDirs.length === 0) {
+		log.warn(`The artifact for ${appDir} describes no locale directories — loading the app instead.`);
+		return loadSingleApp(appDir, discoveryRoot, projectConfig);
+	}
+	return config;
+}
+async function loadSingleApp(appDir, discoveryRoot, projectConfig) {
+	const kit = await loadKit(appDir);
+	let nuxt;
+	try {
+		nuxt = await kit.loadNuxt({
+			cwd: appDir,
+			dotenv: { cwd: appDir },
+			overrides: {
+				logLevel: "silent",
+				vite: { clearScreen: false }
+			}
+		});
+	} catch (_error) {
+		log.warn(`Initial loadNuxt failed for ${appDir}, retrying with ready:false...`);
+		try {
+			nuxt = await kit.loadNuxt({
+				cwd: appDir,
+				dotenv: { cwd: appDir },
+				ready: false,
+				overrides: {
+					logLevel: "silent",
+					vite: { clearScreen: false }
+				}
+			});
+		} catch (retryError) {
+			throw new ConfigError(`Failed to load Nuxt config from ${appDir}: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
+		}
+	}
+	try {
+		return await extractI18nConfig(nuxt, appDir, discoveryRoot, projectConfig);
+	} finally {
+		await nuxt.close();
+	}
+}
+async function loadAndMergeApps(appDirs, discoveryRoot, projectConfig) {
+	const merger = new AppMerger();
+	for (const appDir of appDirs) {
+		log.info(`Loading Nuxt app: ${relative(discoveryRoot, appDir) || "."}`);
+		let appConfig;
+		try {
+			appConfig = await loadApp(appDir, discoveryRoot, projectConfig);
+		} catch (error) {
+			log.warn(`Failed to load app at ${appDir}: ${toErrorMessage(error)}`);
+			continue;
+		}
+		await merger.add(appConfig, discoveryRoot);
+	}
+	if (merger.localeDirs.length === 0) throw new ConfigError(`No locale directories found in any Nuxt app under ${discoveryRoot}. Make sure your Nuxt apps have i18n/locales/ directories with JSON files.`);
+	return merger.toConfig(discoveryRoot, projectConfig ?? void 0, applyLocaleOverride(merger.locales, projectConfig?.locales));
+}
+async function extractI18nConfig(nuxt, appDir, discoveryRoot, projectConfig) {
+	const nuxtOptions = nuxt.options;
+	const i18nOptions = nuxtOptions.i18n;
+	const layers = nuxtOptions._layers ?? [];
+	if (!i18nOptions) throw new ConfigError(`No i18n configuration found in nuxt.config at ${appDir}. Make sure @nuxtjs/i18n is configured.`);
+	const defaultLocale = i18nOptions.defaultLocale ?? "en";
+	log.debug(`Default locale: ${defaultLocale}`);
+	const locales = (i18nOptions.locales ?? []).filter((l) => typeof l === "object" && l !== null).map((l) => ({
+		code: String(l.code ?? ""),
+		language: String(l.language ?? l.iso ?? ""),
+		file: String(l.file ?? ""),
+		name: l.name ? String(l.name) : void 0
+	})).filter((l) => l.code && l.file);
+	if (locales.length === 0) throw new ConfigError("No locales found in i18n configuration. Make sure locales are defined with code and file properties.");
+	const fallbackLocale = normalizeFallbackLocale(i18nOptions.fallbackLocale, defaultLocale);
+	const localeDirs = await discoverLocaleDirs(layers, i18nOptions, discoveryRoot);
+	const layerRootDirs = [...new Set(layers.map((l) => l.config.rootDir))];
+	if (layerRootDirs.length === 0) layerRootDirs.push(appDir);
+	const usedLayerNamesForApp = /* @__PURE__ */ new Set();
+	const appLayerNames = layers.map((l) => deriveLayerName(l.config.rootDir, discoveryRoot, usedLayerNamesForApp));
+	const appInfo = {
+		name: deriveLayerName(appDir, discoveryRoot, /* @__PURE__ */ new Set()),
+		rootDir: appDir,
+		layers: appLayerNames
+	};
+	return {
+		rootDir: appDir,
+		defaultLocale,
+		fallbackLocale,
+		locales: applyLocaleOverride(locales, projectConfig?.locales),
+		localeDirs,
+		layerRootDirs,
+		projectConfig: projectConfig ?? void 0,
+		apps: [appInfo]
+	};
+}
+async function discoverLocaleDirs(layers, i18nOptions, discoveryRoot) {
+	const dirs = [];
+	const resolvedPaths = /* @__PURE__ */ new Map();
+	const usedLayerNames = /* @__PURE__ */ new Set();
+	for (const layer of layers) {
+		const layerRootDir = layer.config.rootDir;
+		const layerName = deriveLayerName(layerRootDir, discoveryRoot, usedLayerNames);
+		usedLayerNames.add(layerName);
+		const layerI18n = layer.config.i18n ?? i18nOptions;
+		const langDir = layerI18n.langDir ?? "locales";
+		const resolvedDir = resolve(layerRootDir, layerI18n.restructureDir ?? "i18n", langDir);
+		if (!existsSync(resolvedDir)) {
+			log.debug(`Locale dir not found for layer '${layerName}': ${resolvedDir}`);
+			continue;
+		}
+		const realDir = await realpath(resolvedDir).catch(() => resolvedDir);
+		if (!resolvedPaths.has(realDir)) {
+			const jsonFiles = (await readdir(resolvedDir)).filter((f) => f.endsWith(".json"));
+			if (jsonFiles.length === 0) {
+				log.debug(`No JSON files in locale dir for layer '${layerName}': ${resolvedDir}`);
+				continue;
+			}
+			log.debug(`Found locale dir for layer '${layerName}': ${resolvedDir} (${jsonFiles.length} files)`);
+		}
+		claimLocaleDir(dirs, resolvedPaths, {
+			path: resolvedDir,
+			layer: layerName,
+			layerRootDir
+		}, realDir);
+	}
+	if (dirs.length === 0) throw new ConfigError("No locale directories found. Make sure your Nuxt layers have i18n/locales/ directories with JSON files.");
+	return dirs;
+}
+//#endregion
+//#region src/adapters/laravel/index.ts
+var LaravelAdapter = class {
+	name = "laravel";
+	label = "Laravel";
+	localeFileFormat = "php-array";
+	async detect(projectDir) {
+		let score = 0;
+		if (existsSync(join(projectDir, "artisan"))) score += 2;
+		try {
+			const raw = await readFile(join(projectDir, "composer.json"), "utf-8");
+			const require = JSON.parse(raw).require;
+			if (require && "laravel/framework" in require) score += 2;
+		} catch {}
+		const langDir = findLangDir(projectDir);
+		if (langDir) {
+			if (await hasLocaleContent(langDir)) score += 1;
+		}
+		return score;
+	}
+	async resolve(projectDir, projectConfig) {
+		const langDir = findLangDir(projectDir);
+		if (!langDir) throw new ConfigError(`No lang/ or resources/lang/ directory found in ${projectDir}. Make sure your Laravel project has a locale directory.`);
+		const format = resolveFormat(langDir, projectConfig?.localeFileFormat);
+		const localeCodes = await discoverLocaleCodes(langDir, format);
+		if (localeCodes.length === 0) throw new ConfigError(getFormatError(langDir, format));
+		const { defaultLocale, fallbackLocale, configLocales } = await extractLocaleConfig(projectDir);
+		const allCodes = mergeLocaleCodes(localeCodes, configLocales);
+		const locales = applyLocaleOverride(allCodes.map((code) => ({
+			code,
+			language: code,
+			...format === "json" ? { file: `${code}.json` } : {}
+		})), projectConfig?.locales);
+		const localeDirs = [{
+			path: langDir,
+			layer: "root",
+			layerRootDir: projectDir
+		}];
+		log.info(`Discovered ${locales.length} locale(s) in ${langDir} (${format}): ${allCodes.join(", ")}`);
+		return {
+			rootDir: projectDir,
+			defaultLocale,
+			fallbackLocale,
+			locales,
+			localeDirs,
+			layerRootDirs: [projectDir],
+			projectConfig: projectConfig ?? void 0,
+			localeFileFormat: format,
+			apps: [{
+				name: "root",
+				rootDir: projectDir,
+				layers: ["root"]
+			}]
+		};
+	}
+};
+function resolveFormat(langDir, override) {
+	if (override) return override;
+	const hasJson = existsSync(join(langDir, "en.json")) || existsSync(join(langDir, "de.json")) || existsSync(join(langDir, "fr.json"));
+	if (hasPhpSubdirsSync(langDir)) return "php-array";
+	if (hasJson) return "json";
+	return "php-array";
+}
+function hasPhpSubdirsSync(langDir) {
+	try {
+		const entries = readdirSync(langDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory() || entry.name === "vendor") continue;
+			if (readdirSync(join(langDir, entry.name)).some((f) => f.endsWith(".php"))) return true;
+		}
+	} catch {}
+	return false;
+}
+function getFormatError(langDir, format) {
+	if (format === "json") return `No JSON locale files found in ${langDir}. Expected files like lang/en.json, lang/de.json.`;
+	return `No locale subdirectories found in ${langDir}. Expected directories like lang/en/, lang/de/.`;
+}
+async function hasLocaleContent(langDir) {
+	if ((await readdir(langDir).catch(() => [])).some((f) => f.endsWith(".json"))) return true;
+	return hasPhpContent(langDir);
+}
+async function discoverLocaleCodes(langDir, format) {
+	if (format === "json") return discoverJsonLocales(langDir);
+	return findLocaleSubdirs(langDir);
+}
+async function discoverJsonLocales(langDir) {
+	return (await readdir(langDir).catch(() => [])).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, "")).sort();
+}
+async function hasPhpContent(langDir) {
+	return (await findLocaleSubdirs(langDir)).length > 0;
+}
+/**
+* Laravel 9+ uses root-level `lang/`, older versions use `resources/lang/`.
+*/
+function findLangDir(projectDir) {
+	const candidates = [join(projectDir, "lang"), join(projectDir, "resources", "lang")];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+	return null;
+}
+async function findLocaleSubdirs(langDir) {
+	let entries;
+	try {
+		entries = await readdir(langDir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	const locales = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory() || entry.name === "vendor") continue;
+		if ((await readdir(join(langDir, entry.name)).catch(() => [])).some((f) => f.endsWith(".php"))) locales.push(entry.name);
+	}
+	return locales.sort();
+}
+/**
+* Extract default and fallback locale from config/app.php.
+*/
+async function extractLocaleConfig(projectDir) {
+	const configPath = join(projectDir, "config", "app.php");
+	let content;
+	try {
+		content = await readFile(configPath, "utf-8");
+	} catch {
+		log.debug("No config/app.php found, using defaults");
+		return {
+			defaultLocale: "en",
+			fallbackLocale: { default: ["en"] },
+			configLocales: []
+		};
+	}
+	const defaultLocale = extractPhpConfigValue(content, "locale") ?? "en";
+	const fallbackValue = extractPhpConfigValue(content, "fallback_locale") ?? defaultLocale;
+	const configLocales = extractPhpArrayValue(content, "locales");
+	log.debug(`Extracted locale config: locale=${defaultLocale}, fallback=${fallbackValue}, config locales=${configLocales.length}`);
+	return {
+		defaultLocale,
+		fallbackLocale: { default: [fallbackValue] },
+		configLocales
+	};
+}
+function extractPhpConfigValue(content, key) {
+	const envPattern = new RegExp(`['"]${key}['"]\\s*=>\\s*env\\s*\\(\\s*['"][^'"]*['"]\\s*,\\s*['"]([^'"]+)['"]\\s*\\)`);
+	const envMatch = content.match(envPattern);
+	if (envMatch) return envMatch[1] ?? null;
+	const directPattern = new RegExp(`['"]${key}['"]\\s*=>\\s*['"]([^'"]+)['"]`);
+	const directMatch = content.match(directPattern);
+	if (directMatch) return directMatch[1] ?? null;
+	return null;
+}
+function extractPhpArrayValue(content, key) {
+	const pattern = new RegExp(`['"]${key}['"]\\s*=>\\s*\\[([^\\]]*)]`);
+	const arrayBody = content.match(pattern)?.[1];
+	if (arrayBody === void 0) return [];
+	const itemPattern = /['"]([^'"]+)['"]/g;
+	const items = [];
+	let itemMatch;
+	while ((itemMatch = itemPattern.exec(arrayBody)) !== null) {
+		const item = itemMatch[1];
+		if (item) items.push(item);
+	}
+	return items;
+}
+function mergeLocaleCodes(filesystemCodes, configCodes) {
+	const seen = new Set(filesystemCodes);
+	const merged = [...filesystemCodes];
+	for (const code of configCodes) if (!seen.has(code)) {
+		seen.add(code);
+		merged.push(code);
+	}
+	return merged.sort();
+}
+//#endregion
+//#region src/adapters/generic/index.ts
+/**
+* Where a project that declares no `localeDirs` plausibly keeps its locale
+* files, probed in order. Deliberately short and framework-neutral: it holds
+* the layouts a Vue, Svelte or plain-bundler project ends up with by
+* convention, and none that belong to an adapter of their own (`lang/` is
+* Laravel's, `messages/` and `public/locales` are React's).
+*
+* Ordered the way `init` probes the same layouts, so that a project with two
+* of them resolves to the directory init writes down rather than to a
+* different one.
+*/
+const COMMON_LOCALE_DIRS$1 = [
+	"locales",
+	"src/locales",
+	"i18n/locales",
+	"src/i18n/locales",
+	"src/i18n"
+];
+/** A declaration beats every other adapter's signals. */
+const DECLARED = 10;
+/**
+* A probed directory beats nothing: every framework adapter scores at least
+* this much on a project it recognizes, so discovery only decides projects no
+* adapter claims.
+*/
+const DISCOVERED = 1;
+var GenericAdapter = class {
+	name = "generic";
+	label = "Generic";
+	localeFileFormat = "json";
+	async detect(projectDir) {
+		const config = await loadProjectConfig(projectDir);
+		if (config?.localeDirs && config.localeDirs.length > 0 && config.defaultLocale) return DECLARED;
+		return await findLocaleDir$1(projectDir) ? DISCOVERED : 0;
+	}
+	async resolve(projectDir, projectConfig) {
+		const localeDirs = await resolveLocaleDirs(projectDir, projectConfig);
+		for (const dir of localeDirs) if (!existsSync(dir.path)) throw new ConfigError(`Locale directory does not exist: ${dir.path}`);
+		const detectedFormat = await detectFormatInDir(localeDirs[0].path) ?? "json";
+		const discoveredLocales = projectConfig?.locales ?? await discoverLocales$1(localeDirs, detectedFormat);
+		const [firstLocale] = discoveredLocales;
+		if (firstLocale === void 0) throw new ConfigError(`No locale files found in ${localeDirs.map((d) => d.path).join(", ")}`);
+		const defaultLocale = projectConfig?.defaultLocale ?? firstLocale;
+		const locales = await Promise.all(discoveredLocales.map(async (code) => ({
+			code,
+			language: code,
+			...await flatFileFor(localeDirs, code, detectedFormat)
+		})));
+		log.info(`Generic adapter: ${locales.length} locale(s), format=${detectedFormat}, dirs=${localeDirs.map((d) => d.layer).join(", ")}`);
+		return {
+			rootDir: projectDir,
+			defaultLocale,
+			fallbackLocale: { default: [defaultLocale] },
+			locales,
+			localeDirs,
+			layerRootDirs: [projectDir],
+			...projectConfig ? { projectConfig } : {},
+			localeFileFormat: detectedFormat,
+			apps: [{
+				name: "default",
+				rootDir: projectDir,
+				layers: localeDirs.map((d) => d.layer)
+			}]
+		};
+	}
+};
+/**
+* The directories to read, declared first: a project that writes down where
+* its locale files are has settled the question, and probing is only for the
+* one that has not.
+*/
+async function resolveLocaleDirs(projectDir, projectConfig) {
+	const declared = projectConfig?.localeDirs ?? [];
+	if (declared.length > 0) return declared.map((entry) => typeof entry === "string" ? {
+		path: resolve(projectDir, entry),
+		layer: "default",
+		layerRootDir: projectDir
+	} : {
+		path: resolve(projectDir, entry.path),
+		layer: entry.layer,
+		layerRootDir: projectDir
+	});
+	const probed = await findLocaleDir$1(projectDir);
+	if (!probed) throw new ConfigError(`GenericAdapter requires both "localeDirs" and "defaultLocale" in .i18n-mcp.json when the locale files are not in a conventional directory. Looked in ${projectDir} for: ${COMMON_LOCALE_DIRS$1.join(", ")}.`);
+	return [{
+		path: probed,
+		layer: "default",
+		layerRootDir: projectDir
+	}];
+}
+/**
+* The first conventional directory that holds locales, by the same rule that
+* resolves one. Judging a candidate on its contents rather than its existence
+* is what keeps an empty `src/i18n` beside a populated `locales` from claiming
+* a project and then resolving to nothing.
+*
+* Runs on every project the CLI is pointed at, including ones this adapter
+* will lose, so it reads directory entries and nothing else — no project code.
+*/
+async function findLocaleDir$1(projectDir) {
+	for (const candidate of COMMON_LOCALE_DIRS$1) {
+		const path = join(projectDir, candidate);
+		if (!existsSync(path)) continue;
+		const format = await detectFormatInDir(path);
+		if (!format) continue;
+		if ((await discoverLocales$1([{
+			path,
+			layer: "default",
+			layerRootDir: projectDir
+		}], format)).length > 0) return path;
+	}
+	return null;
+}
+/**
+* The flat file for a locale, when there is one. Absent for a namespaced
+* layout, where each namespace is its own file and no single name applies.
+*/
+async function flatFileFor(localeDirs, code, format) {
+	for (const ext of getFormat(format).extensions) for (const dir of localeDirs) if (existsSync(join(dir.path, `${code}${ext}`))) return { file: `${code}${ext}` };
+	return {};
+}
+const NON_LOCALE_NAMES = new Set([
+	"index",
+	"readme",
+	"config",
+	"vendor",
+	"node_modules",
+	".git",
+	".DS_Store"
+]);
+async function discoverLocales$1(localeDirs, format) {
+	const codes = /* @__PURE__ */ new Set();
+	for (const dir of localeDirs) {
+		let entries;
+		try {
+			entries = await readdir(dir.path, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		const extensions = getFormat(format).extensions;
+		for (const entry of entries) {
+			if (entry.name.startsWith(".")) continue;
+			const flatExt = extensions.find((ext) => entry.name.toLowerCase().endsWith(ext));
+			if (entry.isFile() && flatExt) {
+				const code = entry.name.slice(0, -flatExt.length);
+				if (!NON_LOCALE_NAMES.has(code.toLowerCase())) codes.add(code);
+			} else if (entry.isDirectory() && !NON_LOCALE_NAMES.has(entry.name.toLowerCase())) {
+				if ((await readdir(join(dir.path, entry.name)).catch(() => [])).some((f) => extensions.some((ext) => f.toLowerCase().endsWith(ext)))) codes.add(entry.name);
+			}
+		}
+	}
+	return [...codes].sort();
+}
+//#endregion
+//#region src/config/framework/execute.ts
+/**
+* Executing config files that belong to *other* tools.
+*
+* Where a project already declares its locales authoritatively — next-intl's
+* `defineRouting`, next-translate's `i18n.js`, `next.config`'s `i18n` block —
+* reading it beats guessing from directory order. The only reason the adapters
+* ever guessed is that the CLI could not run TypeScript.
+*
+* The rule for everything in here: **never load-bearing**. A real
+* `next.config.js` is wrapped in `withNextIntl(...)` or `withSentryConfig(...)`
+* and throws without the right env or plugins installed. A file we cannot run
+* means falling back to the heuristics that were the only behaviour until now,
+* with a warning — never a failed command. It is the rule the Nuxt adapter's
+* artifact reader already follows, for the same reason.
+*/
+/**
+* Run one config file and hand back its exports, or null if anything at all
+* went wrong. Callers treat null as "no information", not as an error.
+*/
+async function executeConfig(path, options = {}) {
+	try {
+		const { createJiti } = await import("jiti");
+		const module = await createJiti(import.meta.url, {
+			interopDefault: false,
+			...options.alias ? { alias: options.alias } : {}
+		}).import(path);
+		return module && typeof module === "object" ? module : null;
+	} catch (error) {
+		log.warn(`Could not read ${path}: ${toErrorMessage(error)}. Falling back to directory detection — declare the value in i18n-kit.config.ts to be sure of it.`);
+		return null;
+	}
+}
+/**
+* The first of `candidates` that exists under `projectDir`, as an absolute
+* path.
+*
+* Absolute, not merely joined: `--projectDir playground/react` is a relative
+* path, and a relative path handed to jiti is read as a bare module specifier
+* and resolved against `node_modules`, where it is never found.
+*/
+function firstExisting(projectDir, candidates) {
+	for (const candidate of candidates) {
+		const path = resolve(projectDir, candidate);
+		if (existsSync(path)) return path;
+	}
+	return null;
+}
+/**
+* Locate one of the stub modules in `./stubs/`, as a path jiti can be aliased
+* to. Returns null when it cannot be found, which leaves normal resolution in
+* place.
+*
+* A stub has to survive the build as a *file* — it is referred to by path and
+* never imported, so it is declared as its own tsdown entry rather than
+* bundled. That gives it two possible homes, and this resolves against the
+* location of this module, which sits beside `stubs/` in the source tree and
+* at the root of `dist/` in the bundle.
+*/
+function resolveStub(name) {
+	const candidates = [`./stubs/${name}.ts`, `./config/framework/stubs/${name}.js`];
+	for (const candidate of candidates) {
+		const path = fileURLToPath(new URL(candidate, import.meta.url));
+		if (existsSync(path)) return path;
+	}
+	return null;
+}
+/** A module's default export, or the module itself for a CJS `module.exports`. */
+function defaultExport(module) {
+	return "default" in module ? module.default : module;
+}
+/** Narrow an unknown to a plain object, the shape every reader here digs into. */
+function asObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+/** A non-empty string, or undefined — config values are not to be trusted. */
+function asString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+/** An array of non-empty strings, or undefined. */
+function asStringArray(value) {
+	if (!Array.isArray(value)) return void 0;
+	const strings = value.filter((v) => typeof v === "string" && v.length > 0);
+	return strings.length > 0 ? strings : void 0;
+}
+//#endregion
+//#region src/config/framework/next.ts
+/**
+* Reading what a Next.js project already says about its locales.
+*
+* Three setups declare it authoritatively, and the adapter used to read none
+* of them — it took the alphabetically first file in `messages/` and called
+* that the default locale, so `{de,en,fr}.json` made German the source of
+* truth for an English project (#296).
+*/
+/** next-intl: `defineRouting({ locales, defaultLocale })`, usually re-exported as `routing`. */
+const ROUTING_FILES = [
+	"src/i18n/routing.ts",
+	"src/i18n/routing.js",
+	"i18n/routing.ts",
+	"i18n/routing.js"
+];
+/** next-translate: a top-level `i18n.js` consumed by `nextTranslate(...)`. */
+const NEXT_TRANSLATE_FILES = [
+	"i18n.js",
+	"i18n.ts",
+	"i18n.mjs"
+];
+/** Pages Router: `i18n: { locales, defaultLocale }` in the Next config itself. */
+const NEXT_CONFIG_FILES$1 = [
+	"next.config.ts",
+	"next.config.js",
+	"next.config.mjs"
+];
+/**
+* The first source that yields something, in order of how specifically it is
+* about i18n: a routing file exists only to declare locales, whereas
+* `next.config` is mostly about everything else and the likeliest to throw.
+*
+* Returns null when no source could be read — every failure is a warning and a
+* fallback to directory detection, never an error.
+*/
+async function readNextI18n(projectDir) {
+	const readers = [
+		readRouting,
+		readNextTranslate,
+		readNextConfig
+	];
+	for (const reader of readers) {
+		const found = await reader(projectDir);
+		if (found?.defaultLocale || found?.locales) {
+			log.info(`Read i18n from ${found.source}: defaultLocale=${found.defaultLocale ?? "(none)"}`);
+			return found;
+		}
+	}
+	return null;
+}
+/**
+* next-intl. `defineRouting` returns the object it was handed, so the exported
+* routing object carries `locales` and `defaultLocale` verbatim — which is why
+* substituting it (only when it is missing; see `routingAlias`) cannot change
+* the answer.
+*/
+async function readRouting(projectDir) {
+	const path = firstExisting(projectDir, ROUTING_FILES);
+	if (!path) return null;
+	const module = await executeConfig(path, { alias: routingAlias(path) });
+	if (!module) return null;
+	for (const candidate of [module.routing, defaultExport(module)]) {
+		const routing = asObject(candidate);
+		if (!routing) continue;
+		const defaultLocale = asString(routing.defaultLocale);
+		const locales = asStringArray(routing.locales);
+		if (defaultLocale || locales) return {
+			...defaultLocale ? { defaultLocale } : {},
+			...locales ? { locales } : {},
+			source: path
+		};
+	}
+	return null;
+}
+/**
+* Substitute `defineRouting` only when the real one cannot be found from the
+* routing file's own location.
+*
+* The real package always wins where it is installed — it is the authority on
+* its own API, and a substitution that silently shadowed it would be the kind
+* of quiet divergence this whole line of work is about. The stub is purely a
+* rescue for the case where the file exists and its dependencies do not, which
+* is a fresh clone, a CI job that skipped install, or a fixture. Reading a
+* declaration should not require a `node_modules` to be present.
+*/
+function routingAlias(routingPath) {
+	if (resolvableFrom("next-intl/routing", routingPath)) return void 0;
+	const path = resolveStub("next-intl-routing");
+	if (!path) return void 0;
+	log.debug(`next-intl is not installed for ${routingPath} — reading it with a stubbed defineRouting`);
+	return { "next-intl/routing": path };
+}
+/**
+* `next.config.js` may export `(phase, { defaultConfig }) => config`, sync or
+* async, which Next.js calls for you. An uncalled function is not a config, so
+* without this the `i18n` block of every project using that form is invisible.
+*
+* A function that throws yields nothing, like any other unreadable config.
+*/
+async function resolveConfigExport(exported, path) {
+	if (typeof exported !== "function") return exported;
+	try {
+		return await exported("phase-production-build", { defaultConfig: {} });
+	} catch (error) {
+		log.warn(`Could not evaluate the config function in ${path}: ${toErrorMessage(error)}`);
+		return;
+	}
+}
+function resolvableFrom(specifier, fromFile) {
+	try {
+		createRequire(fromFile).resolve(specifier);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** next-translate's `i18n.js`, a plain object of `{ locales, defaultLocale, pages }`. */
+async function readNextTranslate(projectDir) {
+	const path = firstExisting(projectDir, NEXT_TRANSLATE_FILES);
+	if (!path) return null;
+	const module = await executeConfig(path);
+	if (!module) return null;
+	const config = asObject(defaultExport(module));
+	if (!config) return null;
+	const defaultLocale = asString(config.defaultLocale);
+	const locales = asStringArray(config.locales);
+	if (!defaultLocale && !locales) return null;
+	return {
+		...defaultLocale ? { defaultLocale } : {},
+		...locales ? { locales } : {},
+		source: path
+	};
+}
+/**
+* The Pages Router's `i18n` block. Read last because this is the file most
+* likely to throw: in a real project it is wrapped in `withNextIntl(...)`,
+* `withSentryConfig(...)` and whatever else, and needs their env to run.
+*/
+async function readNextConfig(projectDir) {
+	const path = firstExisting(projectDir, NEXT_CONFIG_FILES$1);
+	if (!path) return null;
+	const module = await executeConfig(path);
+	if (!module) return null;
+	const config = asObject(await resolveConfigExport(defaultExport(module), path));
+	const i18n = config && asObject(config.i18n);
+	if (!i18n) return null;
+	const defaultLocale = asString(i18n.defaultLocale);
+	const locales = asStringArray(i18n.locales);
+	if (!defaultLocale && !locales) return null;
+	return {
+		...defaultLocale ? { defaultLocale } : {},
+		...locales ? { locales } : {},
+		source: path
+	};
+}
+//#endregion
+//#region src/adapters/shared.ts
+/**
+* Helpers for an adapter that resolves a project to a single locale directory.
+*/
+const NUXT_CONFIG_FILES = [
+	"nuxt.config.ts",
+	"nuxt.config.js",
+	"nuxt.config.mjs"
+];
+async function loadPackageJson(projectDir) {
+	try {
+		const raw = await readFile(join(projectDir, "package.json"), "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function collectDependencies(pkg) {
+	return {
+		...pkg.dependencies ?? {},
+		...pkg.devDependencies ?? {}
+	};
+}
+function hasNuxtConfig(dir) {
+	return NUXT_CONFIG_FILES.some((f) => existsSync(join(dir, f)));
+}
+function noLocaleDirError(projectDir, searchedDirs) {
+	return new ConfigError(`No locale directory found in ${projectDir}. Looked in: ` + searchedDirs.join(", ") + ". Configure a .i18n-mcp.json with localeDirs for custom paths.");
+}
+/** Build the I18nConfig for a project with a single locale directory ('root' layer). */
+function buildSingleDirConfig(opts) {
+	return {
+		rootDir: opts.projectDir,
+		defaultLocale: opts.defaultLocale,
+		fallbackLocale: { default: [opts.defaultLocale] },
+		locales: opts.locales,
+		localeDirs: [{
+			path: opts.localeDir,
+			layer: "root",
+			layerRootDir: opts.projectDir
+		}],
+		layerRootDirs: [opts.projectDir],
+		projectConfig: opts.projectConfig ?? void 0,
+		apps: [{
+			name: "default",
+			rootDir: opts.projectDir,
+			layers: ["root"]
+		}]
+	};
+}
+//#endregion
+//#region src/adapters/react/index.ts
+const COMMON_LOCALE_DIRS = [
+	"messages",
+	"public/locales",
+	"locales",
+	"src/i18n",
+	"src/locales",
+	"i18n"
+];
+const NEXT_CONFIG_FILES = [
+	"next.config.ts",
+	"next.config.js",
+	"next.config.mjs"
+];
+const NUXT_INDICATORS = ["@nuxt/kit", "nuxt"];
+const VUE_INDICATORS = ["vue"];
+const I18N_DEPS = [
+	"next-intl",
+	"next-translate",
+	"next-i18next",
+	"react-i18next",
+	"react-intl"
+];
+const SKIP_DIRS = new Set([
+	"node_modules",
+	".git",
+	".DS_Store"
+]);
+var ReactAdapter = class {
+	name = "react";
+	label = "React / Next.js";
+	localeFileFormat = "json";
+	async detect(projectDir) {
+		const pkg = await loadPackageJson(projectDir);
+		if (!pkg) return 0;
+		const allDeps = collectDependencies(pkg);
+		if (isConflictingFramework(projectDir, allDeps)) return 0;
+		const isNext = "next" in allDeps;
+		const isReact = "react" in allDeps && "react-dom" in allDeps;
+		if (!isNext && !isReact) return 0;
+		return computeScore(projectDir, allDeps, isNext);
+	}
+	async resolve(projectDir, projectConfig) {
+		const localeDir = await findLocaleDir(projectDir);
+		if (!localeDir) throw noLocaleDirError(projectDir, COMMON_LOCALE_DIRS);
+		const locales = await discoverLocales(localeDir);
+		const [firstLocale] = locales;
+		if (firstLocale === void 0) throw new ConfigError(`No locale files found in ${localeDir}. Make sure your React/Next.js project has locale directories like messages/en/ or locale JSON files.`);
+		const framework = await readNextI18n(projectDir);
+		return buildSingleDirConfig({
+			projectDir,
+			localeDir,
+			defaultLocale: projectConfig?.defaultLocale ?? framework?.defaultLocale ?? firstLocale.code,
+			locales: applyLocaleOverride(locales, projectConfig?.locales),
+			projectConfig
+		});
+	}
+};
+function isConflictingFramework(projectDir, deps) {
+	for (const indicator of NUXT_INDICATORS) if (indicator in deps) return true;
+	for (const indicator of VUE_INDICATORS) if (indicator in deps) return true;
+	return hasNuxtConfig(projectDir);
+}
+function hasNextConfig(projectDir) {
+	return NEXT_CONFIG_FILES.some((f) => existsSync(join(projectDir, f)));
+}
+async function computeScore(projectDir, deps, isNext) {
+	let score = isNext ? 5 : 3;
+	if (I18N_DEPS.some((dep) => dep in deps)) score += 2;
+	if (isNext && hasNextConfig(projectDir)) score += 1;
+	try {
+		const localeDir = findLocaleDirSync(projectDir);
+		if (localeDir) {
+			if (readdirSync(localeDir).some((e) => isLocaleContent(join(localeDir, e)))) score += 2;
+		}
+	} catch {}
+	return score;
+}
+async function findLocaleDir(projectDir) {
+	const fromConfig = await tryNextConfig(projectDir);
+	if (fromConfig) return fromConfig;
+	return findLocaleDirSync(projectDir);
+}
+function findLocaleDirSync(projectDir) {
+	for (const dir of COMMON_LOCALE_DIRS) {
+		const fullPath = join(projectDir, dir);
+		if (existsSync(fullPath)) return fullPath;
+	}
+	return null;
+}
+function isLocaleContent(path) {
+	if (path.endsWith(".json")) return true;
+	return isLocaleSubdir(path);
+}
+function isLocaleSubdir(path) {
+	if (!existsSync(path)) return false;
+	try {
+		if (!statSync(path).isDirectory()) return false;
+		return readdirSync(path).some((f) => f.endsWith(".json"));
+	} catch {
+		return false;
+	}
+}
+async function tryNextConfig(projectDir) {
+	for (const file of NEXT_CONFIG_FILES) {
+		const fullPath = join(projectDir, file);
+		if (!existsSync(fullPath)) continue;
+		const result = await tryExtractFromNextConfig(projectDir, fullPath);
+		if (result) return result;
+	}
+	return null;
+}
+async function tryExtractFromNextConfig(projectDir, configPath) {
+	try {
+		const content = await readFile(configPath, "utf-8");
+		if (/createNextIntlPlugin/.test(content) && existsSync(join(projectDir, "messages"))) return join(projectDir, "messages");
+		if (/next-translate/.test(content) && existsSync(join(projectDir, "locales"))) return join(projectDir, "locales");
+		return tryExtractPathFromConfig(projectDir, content);
+	} catch {
+		return null;
+	}
+}
+function tryExtractPathFromConfig(projectDir, content) {
+	const rawPath = content.match(/(?:messages|localeDir|locales)\s*:\s*['"]([^'"]+)/)?.[1];
+	if (!rawPath) return null;
+	const path = rawPath.replace(/\/\*\/\*$/, "").replace(/\/\*$/, "");
+	return existsSync(join(projectDir, path)) ? join(projectDir, path) : null;
+}
+async function discoverLocales(localeDir) {
+	let entries;
+	try {
+		entries = await readdir(localeDir);
+	} catch {
+		return [];
+	}
+	const localeCodes = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (SKIP_DIRS.has(entry) || entry.startsWith(".")) continue;
+		if (isLocaleSubdir(join(localeDir, entry))) localeCodes.add(entry);
+	}
+	if (localeCodes.size > 0) return [...localeCodes].sort().map((code) => ({
+		code,
+		language: code
+	}));
+	return entries.filter((entry) => entry.endsWith(".json")).sort().map((file) => ({
+		code: file.replace(/\.json$/, ""),
+		language: file.replace(/\.json$/, ""),
+		file
+	}));
+}
+//#endregion
+//#region src/config/cache.ts
+const configs = /* @__PURE__ */ new Map();
+let lastConfig = null;
+/** The resolved config for a canonical project directory, if one is cached. */
+function getCachedConfigFor(canonicalDir) {
+	return configs.get(canonicalDir);
+}
+function cacheConfig(canonicalDir, config) {
+	configs.set(canonicalDir, config);
+	lastConfig = config;
+}
+/** The most recently resolved config, or null when nothing has been resolved. */
+function getCachedConfig() {
+	return lastConfig;
+}
+function clearConfigCache() {
+	configs.clear();
+	lastConfig = null;
+	log.debug("Config cache cleared");
+}
+//#endregion
+//#region src/config/workspace-graph.ts
+/**
+* Consumer-graph inference from the package manager workspace.
+*
+* Everything the kit does across layers — app-scoped orphan evidence,
+* misplaced usages, unconsumed layers — runs on `config.apps`: which app can
+* render which layer's keys. Only the Nuxt adapter can answer that from
+* framework knowledge, because a Nuxt `extends` chain *is* a consumer graph.
+* For every other stack the same answer is already written down in the
+* workspace: a package that contains a locale dir owns that layer, and a
+* `package.json` dependency edge from one such package to another is a
+* consumption edge.
+*
+* ## What counts as an app
+*
+* An app is a layer-owning workspace package that no *other* layer-owning
+* package depends on, directly or transitively — the roots of the
+* layer-owning subgraph. A package something else depends on (a UI kit, a
+* shared locale package) is not an app of its own: its keys are rendered by
+* its dependents, and calling it an app would tell the orphan scan that its
+* own directory is a place where its keys may legitimately be used, which is
+* evidence the scan must never invent. When every layer-owning package is
+* depended on by another one — a dependency cycle, which package managers
+* permit — there is no root to pick, and then every layer-owning package
+* becomes an app: a graph wider than the truth, never narrower, and narrower
+* is the direction that deletes keys. Each app consumes its own layers plus
+* the layers of its transitive dependencies. Layers that lie outside every
+* workspace package are attached to every app, so an unclaimed locale dir
+* keeps behaving exactly as it does without inference.
+*
+* Inference is refused (`null`) when the project is not a workspace, when no
+* package owns a layer, or when fewer than two apps come out of it — the
+* single-app fallback the adapters build is already correct for those, and
+* replacing it would change names for no gain.
+*/
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies"
+];
+/**
+* Derive the consumer graph for `layers` from the workspace `projectDir` is
+* the root of. Returns null when the workspace cannot answer the question —
+* see the module header for which cases those are and why.
+*/
+async function inferWorkspaceApps(projectDir, layers) {
+	const workspace = await readWorkspacePatterns(projectDir);
+	if (!workspace) return null;
+	const packages = await readWorkspacePackages(projectDir, workspace.patterns);
+	if (packages.length === 0) return null;
+	log.debug(`Workspace consumer graph: ${packages.length} package(s) from ${workspace.source} (${workspace.patterns.join(", ")})`);
+	return buildWorkspaceApps(packages, layers);
+}
+/**
+* The inference itself, over already-read workspace packages: ownership by
+* directory containment, consumption by dependency edges.
+*/
+function buildWorkspaceApps(packages, layers) {
+	const byName = new Map(packages.map((pkg) => [pkg.name, pkg]));
+	const canonical = layers.filter((layer) => !layer.aliasOf);
+	const ownedBy = /* @__PURE__ */ new Map();
+	const unowned = [];
+	for (const layer of canonical) {
+		const owner = ownerOfDir(packages, layer.path);
+		if (!owner) {
+			unowned.push(layer.layer);
+			continue;
+		}
+		const owned = ownedBy.get(owner.name) ?? [];
+		owned.push(layer.layer);
+		ownedBy.set(owner.name, owned);
+	}
+	if (ownedBy.size === 0) return null;
+	const closure = transitiveClosure(byName);
+	const depended = /* @__PURE__ */ new Set();
+	for (const name of ownedBy.keys()) for (const dep of closure.get(name) ?? []) if (dep !== name && ownedBy.has(dep)) depended.add(dep);
+	const roots = [...ownedBy.keys()].filter((name) => !depended.has(name));
+	const appNames = (roots.length > 0 ? roots : [...ownedBy.keys()]).sort();
+	if (appNames.length < 2) return null;
+	return appNames.map((name) => {
+		const consumed = new Set(ownedBy.get(name) ?? []);
+		for (const dep of closure.get(name) ?? []) for (const layer of ownedBy.get(dep) ?? []) consumed.add(layer);
+		for (const layer of unowned) consumed.add(layer);
+		return {
+			name,
+			rootDir: byName.get(name).dir,
+			layers: canonical.filter((layer) => consumed.has(layer.layer)).map((layer) => layer.layer),
+			source: "workspace"
+		};
+	});
+}
+/**
+* The package globs of the workspace rooted at `projectDir`, from whichever
+* package manager declares one. Only `projectDir` itself is inspected: a
+* project detected from inside one workspace package is that package's
+* project, and reading the enclosing workspace would widen the graph past
+* what the caller asked about.
+*/
+async function readWorkspacePatterns(projectDir) {
+	for (const file of ["pnpm-workspace.yaml", "pnpm-workspace.yml"]) {
+		const raw = await readFileOrNull(join(projectDir, file));
+		if (raw === null) continue;
+		const patterns = parsePnpmWorkspacePackages(raw);
+		if (patterns.length > 0) return {
+			patterns,
+			source: file
+		};
+	}
+	const manifest = await readJsonOrNull(join(projectDir, "package.json"));
+	const patterns = manifest ? workspacesField(manifest) : [];
+	return patterns.length > 0 ? {
+		patterns,
+		source: "package.json"
+	} : null;
+}
+/**
+* The `packages:` sequence of a `pnpm-workspace.yaml`, in block or flow form.
+*
+* A hand-rolled reader rather than a YAML parser: the file's other keys are
+* none of our business, one list of strings is the whole contract, and a
+* parser dependency for it would ship in every install.
+*/
+function parsePnpmWorkspacePackages(yamlText) {
+	const patterns = [];
+	let inBlock = false;
+	for (const line of yamlText.split(/\r?\n/)) {
+		if (!inBlock) {
+			const header = /^packages:\s*(.*)$/.exec(line);
+			if (!header) continue;
+			const inline = header[1].trim();
+			if (inline.startsWith("[")) {
+				const end = inline.lastIndexOf("]");
+				return inline.slice(1, end === -1 ? inline.length : end).split(",").map((item) => unquote(item.trim())).filter((item) => item.length > 0);
+			}
+			inBlock = true;
+			continue;
+		}
+		const trimmed = line.trim();
+		if (trimmed === "" || trimmed.startsWith("#")) continue;
+		const item = /^-\s*(.+)$/.exec(trimmed);
+		if (!item) break;
+		const value = unquote(item[1].trim());
+		if (value.length > 0) patterns.push(value);
+	}
+	return patterns;
+}
+/** The npm/yarn `workspaces` field, in both of its accepted spellings. */
+function workspacesField(manifest) {
+	const field = manifest.workspaces;
+	if (Array.isArray(field)) return field.filter((p) => typeof p === "string");
+	if (field && typeof field === "object") {
+		const nested = field.packages;
+		if (Array.isArray(nested)) return nested.filter((p) => typeof p === "string");
+	}
+	return [];
+}
+/** Expand the workspace globs to the packages they name. */
+async function readWorkspacePackages(projectDir, patterns) {
+	const include = patterns.filter((p) => !p.startsWith("!"));
+	const exclude = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+	if (include.length === 0) return [];
+	let manifests;
+	try {
+		manifests = await glob(include.map(toManifestPattern), {
+			cwd: projectDir,
+			absolute: true,
+			ignore: ["**/node_modules/**", ...exclude.map(toManifestPattern)]
+		});
+	} catch (error) {
+		log.debug(`Workspace consumer graph: glob failed (${String(error)})`);
+		return [];
+	}
+	const packages = [];
+	for (const manifest of manifests) {
+		const pkg = await readJsonOrNull(manifest);
+		if (!pkg) continue;
+		const dir = dirname(resolve(manifest));
+		const declared = typeof pkg.name === "string" ? pkg.name.trim() : "";
+		packages.push({
+			dir,
+			name: declared.length > 0 ? declared : basename(dir),
+			deps: dependencyNames(pkg)
+		});
+	}
+	const names = new Set(packages.map((pkg) => pkg.name));
+	return packages.map((pkg) => ({
+		...pkg,
+		deps: pkg.deps.filter((dep) => dep !== pkg.name && names.has(dep))
+	}));
+}
+/**
+* A workspace glob names directories; matching their manifests instead keeps
+* directories that are not packages (a `packages/*` that also holds docs) out
+* of the graph.
+*/
+function toManifestPattern(pattern) {
+	const trimmed = pattern.replace(/\/+$/, "");
+	if (trimmed === "" || trimmed === ".") return "package.json";
+	return `${trimmed}/package.json`;
+}
+/**
+* Dependency names across every field that can carry a workspace edge. The
+* version range is irrelevant — `workspace:*`, a published range, or a file
+* link all mean the same thing once the name matches a workspace package.
+*/
+function dependencyNames(manifest) {
+	const names = [];
+	for (const field of DEPENDENCY_FIELDS) {
+		const deps = manifest[field];
+		if (deps && typeof deps === "object") names.push(...Object.keys(deps));
+	}
+	return names;
+}
+/** The innermost workspace package containing `dir`, if any. */
+function ownerOfDir(packages, dir) {
+	let best;
+	for (const pkg of packages) {
+		if (!isWithin(dir, pkg.dir)) continue;
+		if (!best || pkg.dir.length > best.dir.length) best = pkg;
+	}
+	return best;
+}
+/** True when `child` equals `parent` or lies inside it. */
+function isWithin(child, parent) {
+	const rel = relative(parent, resolve(child));
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+/** Package name → every workspace package reachable from it. Cycle-safe. */
+function transitiveClosure(byName) {
+	const closure = /* @__PURE__ */ new Map();
+	for (const [name, pkg] of byName) {
+		const reachable = /* @__PURE__ */ new Set();
+		const stack = [...pkg.deps];
+		while (stack.length > 0) {
+			const next = stack.pop();
+			if (reachable.has(next)) continue;
+			const dep = byName.get(next);
+			if (!dep) continue;
+			reachable.add(next);
+			stack.push(...dep.deps);
+		}
+		closure.set(name, reachable);
+	}
+	return closure;
+}
+async function readFileOrNull(path) {
+	try {
+		return await readFile(path, "utf-8");
+	} catch {
+		return null;
+	}
+}
+async function readJsonOrNull(path) {
+	const raw = await readFileOrNull(path);
+	if (raw === null) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		log.debug(`Workspace consumer graph: ignoring unparseable ${path}`);
+		return null;
+	}
+}
+/** Strip YAML quoting and any trailing comment from a sequence entry. */
+function unquote(value) {
+	const quoted = /^(['"])(.*?)\1/.exec(value);
+	if (quoted) return quoted[2];
+	const hash = value.indexOf(" #");
+	return (hash === -1 ? value : value.slice(0, hash)).trim();
+}
+//#endregion
+//#region src/config/detector.ts
+registerAdapter(new NuxtAdapter());
+registerAdapter(new LaravelAdapter());
+registerAdapter(new GenericAdapter());
+registerAdapter(new ReactAdapter());
+async function detectI18nConfig(projectDir) {
+	const canonDir = canonicalPath(projectDir);
+	const cached = getCachedConfigFor(canonDir);
+	if (cached) {
+		log.debug("Using cached i18n config");
+		return cached;
+	}
+	log.info(`Detecting i18n config from: ${projectDir}`);
+	const projectConfig = await loadProjectConfig(projectDir);
+	const hint = projectConfig?.framework;
+	const adapter = await detectFramework(projectDir, hint);
+	log.info(`Detected framework: ${adapter.label}`);
+	const config = await adapter.resolve(projectDir, projectConfig);
+	config.framework = adapter.name;
+	await applyConsumerGraph(config, projectConfig, projectDir);
+	cacheConfig(canonDir, config);
+	log.info(`Detected ${config.locales.length} locales, ${config.localeDirs.length} locale directories`);
+	return config;
+}
+/**
+* Settle the consumer graph in `config.apps`, which every cross-layer
+* operation reads, once the adapter has had its say.
+*
+* A declared `apps` list wins outright: it is the only way to correct a graph
+* the tool got wrong, so nothing may override it. Otherwise an adapter that
+* discovered real apps (Nuxt, from its `extends` chain) is left alone, and
+* only the single placeholder app the other adapters emit is open to being
+* replaced by what the workspace says. This lives here rather than in an
+* adapter because it is framework-independent: locale dirs plus package
+* manifests, which every adapter has already produced by this point.
+*/
+async function applyConsumerGraph(config, projectConfig, projectDir) {
+	const declared = projectConfig?.apps;
+	if (declared && declared.length > 0) {
+		config.apps = declared.map((app) => declaredApp(app, config));
+		warnUnknownDeclaredLayers(config);
+		log.debug(`Consumer graph declared in the project config: ${describeApps(config.apps)}`);
+		return;
+	}
+	if (projectConfig?.consumerGraph === "off") return;
+	if (!(config.apps.length === 1 && config.apps[0]?.name === "default")) return;
+	const inferred = await inferWorkspaceApps(projectDir, config.localeDirs);
+	if (!inferred) return;
+	config.apps = inferred;
+	log.debug(`Consumer graph inferred from the workspace: ${describeApps(inferred)}`);
+}
+/**
+* A declared app carries no directory, and the orphan scan needs one to know
+* which source tree is that app's. The first of its layers that has a locale
+* dir supplies it — by convention an app lists its own layer first, and the
+* shared layers it consumes after — falling back to the project root, which
+* scopes nothing away.
+*/
+function declaredApp(app, config) {
+	const own = app.layers.map((layer) => config.localeDirs.find((dir) => dir.layer === layer)).find((dir) => dir !== void 0);
+	return {
+		name: app.name,
+		rootDir: own?.layerRootDir ?? config.rootDir,
+		layers: [...app.layers],
+		source: "declared"
+	};
+}
+/**
+* A declared layer name that matches no locale dir is a typo rather than a
+* layer, and it silently contributes nothing to the graph — so say so.
+*/
+function warnUnknownDeclaredLayers(config) {
+	const known = new Set(config.localeDirs.map((dir) => dir.layer));
+	const unknown = [...new Set(config.apps.flatMap((app) => app.layers))].filter((layer) => !known.has(layer));
+	if (unknown.length === 0) return;
+	log.warn(`Declared apps reference unknown layer(s): ${unknown.join(", ")}. Detected layers: ${[...known].join(", ")}.`);
+}
+function describeApps(apps) {
+	return apps.map((app) => `${app.name} -> [${app.layers.join(", ")}]`).join("; ");
+}
+//#endregion
+export { detectFrameworkMatch as a, discoverNuxtApps as i, clearConfigCache as n, formatForFile as o, getCachedConfig as r, getFormat as s, detectI18nConfig as t };
+
+//# sourceMappingURL=detector-DtFY4qm3.js.map