@the-i18n-kit/cli 4.10.0 → 5.0.0

package/dist/{operations-BCJd7in3.js → operations-CTo44gPu.js}

@@ -1,6 +1,6 @@
 import { i as toErrorMessage, n as FileIOError, r as ToolError, t as ConfigError } from "./errors-coI1dhw1.js";
-import { c as validateProjectConfig, l as log, n as TranslateProviderError, o as CONFIG_FILENAME, s as loadProjectConfig } from "./providers-BAwPjeCy.js";
-import { n as readPhpLocaleFile, t as clearPhpFileCacheEntry } from "./php-reader-DuZ0Hyl_.js";
+import { c as validateProjectConfig, l as log, n as TranslateProviderError, o as CONFIG_FILENAME, s as loadProjectConfig } from "./providers-CHE2ffi6.js";
+import { n as readPhpLocaleFile, t as clearPhpFileCacheEntry } from "./php-reader-3Fgw80zK.js";
 import { createRequire } from "node:module";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
@@ -539,13 +539,6 @@ const layerSchema = z.object({
 	rootDir: z.string().min(1),
 	localeDir: z.string().min(1).optional()
 });
-/**
-* Authoring policy declared in nuxt.config.ts. Deliberately permissive: the
-* shape is owned by ProjectConfig's own schema, which validates it once the two
-* sources are merged. Re-stating it here would be a second definition to keep
-* in step.
-*/
-const policySchema = z.record(z.string(), z.unknown());
 const artifactSchema = z.object({
 	version: z.literal(1),
 	generator: z.string(),
@@ -559,8 +552,7 @@ const artifactSchema = z.object({
 	]),
 	localeFileFormat: z.literal("json"),
 	locales: z.array(localeSchema).min(1),
-	layers: z.array(layerSchema).min(1),
-	policy: policySchema.optional()
+	layers: z.array(layerSchema).min(1)
 });
 /**
 * Read an app's artifact, or null when there isn't a usable one.
@@ -633,7 +625,6 @@ function staleAgainst(artifact, artifactPath) {
 * fallback path producing the same names for the same project.
 */
 async function artifactToConfig(artifact, appDir, discoveryRoot, projectConfig) {
-	const merged = mergePolicy(artifact.policy, projectConfig);
 	const localeDirs = [];
 	const claimed = /* @__PURE__ */ new Map();
 	const usedLayerNames = /* @__PURE__ */ new Set();
@@ -666,31 +657,13 @@ async function artifactToConfig(artifact, appDir, discoveryRoot, projectConfig)
 		rootDir: appDir,
 		defaultLocale: artifact.defaultLocale,
 		fallbackLocale: normalizeFallbackLocale(artifact.fallbackLocale, artifact.defaultLocale),
-		locales: applyLocaleOverride(locales, merged?.locales),
+		locales: applyLocaleOverride(locales, projectConfig?.locales),
 		localeDirs,
 		layerRootDirs,
-		projectConfig: merged,
+		projectConfig: projectConfig ?? void 0,
 		apps: [app]
 	};
 }
-/**
-* Fold the policy declared in nuxt.config.ts into the policy read from
-* .i18n-mcp.json.
-*
-* The file wins on a collision, which should never happen: the module fails the
-* build when a key is declared in both. This is the belt to that braces — an
-* artifact generated before the check existed, or by a newer module, cannot
-* quietly override a value someone can see in their repository.
-*/
-function mergePolicy(policy, projectConfig) {
-	if (!policy || Object.keys(policy).length === 0) return projectConfig ?? void 0;
-	const declared = Object.keys(policy).filter((key) => projectConfig?.[key] !== void 0);
-	if (declared.length > 0) log.warn(`Ignoring ${declared.join(", ")} from the Nuxt artifact: also declared in .i18n-mcp.json, which wins.`);
-	return {
-		...policy,
-		...projectConfig
-	};
-}
 //#endregion
 //#region src/adapters/nuxt/merge-apps.ts
 /**
@@ -711,13 +684,6 @@ var AppMerger = class {
 	apps = [];
 	defaultLocale = "en";
 	fallbackLocale = { default: ["en"] };
-	/**
-	* Authoring policy contributed by the apps themselves — each app's artifact
-	* may carry what its nuxt.config declared. Accumulated first-wins, then
-	* overlaid by .i18n-mcp.json, which is the source a reader can see without
-	* building.
-	*/
-	policy = {};
 	claimedPaths = /* @__PURE__ */ new Map();
 	seenLocaleCodes = /* @__PURE__ */ new Set();
 	usedLayerNames = /* @__PURE__ */ new Set();
@@ -726,17 +692,12 @@ var AppMerger = class {
 			this.defaultLocale = appConfig.defaultLocale;
 			this.fallbackLocale = appConfig.fallbackLocale;
 		}
-		this.collectPolicy(appConfig);
 		const renamedLayers = await this.claimDirs(appConfig, discoveryRoot);
 		this.collectLocales(appConfig);
 		this.collectLayerRoots(appConfig);
 		this.collectApps(appConfig, renamedLayers);
 	}
 	toConfig(discoveryRoot, projectConfig, locales) {
-		const merged = Object.keys(this.policy).length > 0 ? {
-			...this.policy,
-			...projectConfig
-		} : projectConfig;
 		return {
 			rootDir: discoveryRoot,
 			defaultLocale: this.defaultLocale,
@@ -744,7 +705,7 @@ var AppMerger = class {
 			locales,
 			localeDirs: this.localeDirs,
 			layerRootDirs: this.layerRootDirs,
-			projectConfig: merged,
+			projectConfig,
 			apps: this.apps
 		};
 	}
@@ -775,9 +736,6 @@ var AppMerger = class {
 		if (!this.usedLayerNames.has(dir.layer)) return dir.layer;
 		return deriveLayerName(dir.layerRootDir, discoveryRoot, this.usedLayerNames);
 	}
-	collectPolicy(appConfig) {
-		for (const [key, value] of Object.entries(appConfig.projectConfig ?? {})) if (value !== void 0 && this.policy[key] === void 0) this.policy[key] = value;
-	}
 	collectLocales(appConfig) {
 		for (const locale of appConfig.locales) {
 			if (this.seenLocaleCodes.has(locale.code)) continue;
@@ -2103,6 +2061,17 @@ function buildLayerGraph(config) {
 		layersOfApp
 	};
 }
+/** Flatten {@link buildLayerGraph}'s view of `config` into plain JSON. */
+function serializeLayerGraph(config) {
+	const graph = buildLayerGraph(config);
+	const canonical = graph.canonicalLayers.map((dir) => dir.layer);
+	return {
+		canonical,
+		shared: graph.sharedLayers.map((dir) => dir.layer),
+		aliases: Object.fromEntries((config.localeDirs ?? []).filter((dir) => dir.aliasOf).map((dir) => [dir.layer, graph.ownerOf(dir.layer)])),
+		consumers: Object.fromEntries(canonical.map((layer) => [layer, graph.appsUsingLayer(layer)]))
+	};
+}
 //#endregion
 //#region src/io/read-cache.ts
 /**
@@ -2521,7 +2490,7 @@ function detectPhpStyle(content) {
 * are inserted in sorted position among their siblings.
 */
 async function mutatePhpLocaleFile(filePath, mutate) {
-	const { readPhpLocaleFile } = await import("./php-reader-DcgOAhTw.js");
+	const { readPhpLocaleFile } = await import("./php-reader-CpnaPSpZ.js");
 	const data = await readPhpLocaleFile(filePath);
 	const { quoteStyle, indent } = detectPhpStyle(await readFile(filePath, "utf-8"));
 	const reference = structuredClone(data);
@@ -4016,34 +3985,565 @@ function propagateCounts(node) {
 	node.keyCount = total;
 	return total;
 }
-const VUE_NUXT_PATTERNS = {
-	label: "Vue / Nuxt",
-	filePatterns: [
-		"**/*.vue",
-		"**/*.ts",
-		"**/*.tsx",
-		"**/*.js",
-		"**/*.jsx",
-		"**/*.mjs",
-		"**/*.mts"
-	],
-	ignoreDirs: [
-		"node_modules",
-		".nuxt",
-		".output",
-		"dist",
-		".git",
-		"coverage",
-		".tmp"
-	],
-	staticKeyPatterns: [/(?<!\w)(this\.\$te?|\$te?|\bt)\s*\(\s*(['"])((?:(?!\2).)*)\2/g],
-	dynamicKeyPatterns: [/(?<!\w)(this\.\$te?|\$te?|\bt)\s*\(\s*`((?:[^`]|\\.)*)`/g],
-	concatKeyPatterns: [/(?<!\w)(this\.\$te?|\$te?|\bt)\s*\(\s*(['"])((?:(?!\2).)*)\2\s*\+/g],
-	requiresDotForCallee: (callee) => callee === "t",
-	promoteStaticDynamicMatches: true,
-	resolveLocalConsts: true,
-	bareShapes: "js"
-};
+//#endregion
+//#region src/scanner/frontends/oxc.ts
+/**
+* JavaScript, TypeScript and Vue SFCs, read as syntax rather than matched as
+* text (#332).
+*
+* What this buys is one thing: it can follow `t` back to where it came from.
+* A regex sees the name and has to guess from the argument's shape whether the
+* call is a translation — the guess that offered a live key for deletion in
+* #298. Here, a `t` destructured from `useI18n()` is known to be i18n, and a
+* `t` that is anything else is known not to be.
+*/
+const JS_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts",
+	".ts",
+	".tsx"
+]);
+/** Packages whose exports are translation functions. */
+const I18N_MODULES = new Set([
+	"vue-i18n",
+	"@nuxtjs/i18n",
+	"next-intl",
+	"react-i18next",
+	"i18next",
+	"petite-vue-i18n"
+]);
+/** Composables whose destructured `t` is a translation function. */
+const I18N_FACTORIES = new Set([
+	"useI18n",
+	"useTranslation",
+	"useTranslations",
+	"getTranslations"
+]);
+/**
+* Callees that are unambiguous wherever they appear: a Vue template's `$t`, or
+* `this.$t` in an options-API component. Nothing else is named that.
+*/
+const ALWAYS_I18N = new Set([
+	"$t",
+	"$te",
+	"$tc"
+]);
+/**
+* Names that might be a translation function without proving it — the same set
+* the patterns match. Without this the frontend reports every call in the file,
+* and `axios.get('/api/v1')` or `require('node:fs')` become translation keys
+* because their argument happens to contain a dot.
+*
+* A call whose callee resolves to an i18n import is reported whatever it is
+* named, which is the point: the list bounds guesswork, not knowledge.
+*/
+const MAYBE_I18N = new Set([
+	"t",
+	"te",
+	"tc",
+	"$t",
+	"$te",
+	"$tc"
+]);
+function createOxcFrontend() {
+	return {
+		name: "oxc",
+		handles(filePath) {
+			return JS_EXTENSIONS.has(extname(filePath)) || filePath.endsWith(".vue");
+		},
+		async read(content, filePath) {
+			const parse = await loadParser();
+			if (!parse) return null;
+			const blocks = readableBlocks(content, filePath);
+			if (!blocks) return null;
+			const parsed = [];
+			for (const block of blocks) {
+				const ast = parseBlock(parse, block.source, filePath);
+				if (!ast) return null;
+				parsed.push({
+					block,
+					ast
+				});
+			}
+			return collectAcrossBlocks(parsed);
+		}
+	};
+}
+/**
+* The parseable blocks of a file, or null to decline it. A .vue file with
+* neither a template nor a script tag is not an SFC: the block splitter would
+* read only the fragments it recognises and silently drop everything between
+* them — declining hands the whole file to the fallback instead. The same
+* goes for an SFC yielding no blocks at all.
+*/
+function readableBlocks(content, filePath) {
+	if (!filePath.endsWith(".vue")) return [{
+		source: content,
+		lineOffset: 0
+	}];
+	if (!/<template[\s>]|<script[\s>]/.test(content)) return null;
+	const blocks = vueBlocks(content);
+	return blocks.length === 0 ? null : blocks;
+}
+/**
+* An SFC is one scope split across blocks: a template uses what the script
+* declared. Collecting per block would leave `t(`${base}.title`)` in the
+* template unresolvable, and it is the same file.
+*/
+function collectAcrossBlocks(parsed) {
+	const i18nNames = new Set(parsed.flatMap((p) => [...p.ast.i18nNames]));
+	const constants = /* @__PURE__ */ new Map();
+	for (const { ast } of parsed) for (const [name, value] of ast.constants) addConstant(constants, name, value);
+	const sites = [];
+	for (const { block, ast } of parsed) collect({
+		...ast,
+		i18nNames,
+		constants
+	}, sites, lineResolver(block.source, block.lineOffset));
+	return sites;
+}
+/**
+* Loaded on first use rather than at import, so a command that never scans does
+* not pay for a native binary it will not touch. Cached including the failure,
+* so a broken install is reported once and then falls back quietly.
+*/
+let parserPromise;
+function loadParser() {
+	parserPromise ??= import("oxc-parser").then((m) => m.parseSync).catch((error) => {
+		log.warn(`oxc-parser could not be loaded (${error instanceof Error ? error.message : String(error)}) — falling back to pattern matching for JavaScript and TypeScript.`);
+		return null;
+	});
+	return parserPromise;
+}
+function parseBlock(parseSync, source, filePath) {
+	const result = parseSync(filePath.endsWith(".vue") ? "block.ts" : filePath, source);
+	if (result.errors.length > 0) {
+		log.debug(`oxc declined ${filePath}: ${result.errors[0]?.message ?? "parse error"}`);
+		return null;
+	}
+	return {
+		program: result.program,
+		source,
+		i18nNames: collectI18nNames(result.program),
+		constants: collectStringConstants(result.program)
+	};
+}
+/**
+* The names bound to a translation function in this file — imports from an
+* i18n package, and destructures of the composables those packages expose.
+*/
+function collectI18nNames(program) {
+	const names = /* @__PURE__ */ new Set();
+	const factories = /* @__PURE__ */ new Set();
+	walk$1(program, (node) => {
+		if (node.type !== "ImportDeclaration") return;
+		if (typeof node.source?.value !== "string" || !I18N_MODULES.has(node.source.value)) return;
+		readImportSpecifiers(node, names, factories);
+	});
+	walk$1(program, (node) => {
+		if (node.type !== "VariableDeclarator") return;
+		if (!isI18nFactoryCall(node.init, factories)) return;
+		readBoundNames(node.id, names);
+	});
+	return names;
+}
+function isI18nFactoryCall(init, factories) {
+	if (init?.type !== "CallExpression") return false;
+	const callee = calleeName$1(init.callee);
+	return callee !== void 0 && (factories.has(callee) || I18N_FACTORIES.has(callee));
+}
+/** The names a destructure or a plain assignment binds. */
+function readBoundNames(id, names) {
+	if (!id) return;
+	if (id.type === "Identifier") {
+		names.add(id.name);
+		return;
+	}
+	if (id.type !== "ObjectPattern") return;
+	for (const prop of id.properties ?? []) {
+		const local = propertyName(prop);
+		if (local) names.add(local);
+	}
+}
+/** `{ t }` binds `t`; `{ t: translate }` binds `translate`. */
+function propertyName(prop) {
+	return prop.value?.name ?? prop.key?.name;
+}
+/**
+* String constants, so a key assembled from one resolves to the key it names.
+*
+*   const base = 'pages.settings'
+*   t(`${base}.title`)          →  pages.settings.title
+*
+* The regex path approximates this with a table of textual substitutions. Here
+* it is the binding itself, which is the difference between resolving a name
+* and hoping no other name looks like it.
+*/
+function collectStringConstants(program) {
+	const constants = /* @__PURE__ */ new Map();
+	walk$1(program, (node) => {
+		if (node.type !== "VariableDeclarator") return;
+		if (node.id?.type !== "Identifier") return;
+		if (node.init?.type !== "Literal" || typeof node.init.value !== "string") return;
+		addConstant(constants, node.id.name, node.init.value);
+	});
+	return constants;
+}
+function addConstant(table, name, value) {
+	const existing = table.get(name);
+	if (existing === void 0) table.set(name, value);
+	else if (existing !== value) table.set(name, null);
+}
+function readImportSpecifiers(node, names, factories) {
+	for (const spec of node.specifiers ?? []) {
+		const local = spec.local?.name;
+		if (!local) continue;
+		const imported = spec.imported?.name ?? local;
+		if (I18N_FACTORIES.has(imported)) factories.add(local);
+		else names.add(local);
+	}
+}
+/**
+* Offsets to line numbers. The parser reports positions as byte offsets, so
+* the line index is built once per block rather than counted per call site.
+*/
+function lineResolver(source, lineOffset) {
+	const starts = [0];
+	for (let i = 0; i < source.length; i++) if (source[i] === "\n") starts.push(i + 1);
+	return (offset) => {
+		let low = 0;
+		let high = starts.length - 1;
+		while (low < high) {
+			const mid = Math.ceil((low + high) / 2);
+			if ((starts[mid] ?? 0) <= offset) low = mid;
+			else high = mid - 1;
+		}
+		return low + 1 + lineOffset;
+	};
+}
+function collect(parsed, sites, lineAt) {
+	walk$1(parsed.program, (node) => {
+		if (node.type !== "CallExpression") return;
+		const site = toCallSite(node, parsed, lineAt);
+		if (site) sites.push(site);
+	});
+}
+function toCallSite(node, parsed, lineAt) {
+	const callee = resolveCallee(node.callee, parsed.i18nNames);
+	if (!callee) return void 0;
+	if (!callee.resolved && !MAYBE_I18N.has(callee.name)) return void 0;
+	const [first] = node.arguments ?? [];
+	if (!first) return void 0;
+	return {
+		callee: callee.name,
+		binding: callee.resolved ? "resolved" : "ambiguous",
+		argument: readArgument$1(first, parsed),
+		line: lineAt(node.start ?? 0)
+	};
+}
+/**
+* Name a callee and decide whether its binding proves it is i18n.
+*
+* An identifier resolves through what this file bound — an i18n import or a
+* destructure of `useI18n()`. A member call resolves only through its own
+* shape: `$t` is unambiguous on any receiver, and `t` proves i18n only when
+* the receiver itself is an i18n binding (`const i18n = useI18n(); i18n.t(…)`).
+* A local `t` from `useI18n()` says nothing about `client.t(…)` — matching a
+* member by its property name against local bindings would resolve exactly the
+* calls this frontend exists to tell apart.
+*/
+function resolveCallee(node, i18nNames) {
+	if (!node) return void 0;
+	if (node.type === "Identifier") return {
+		name: node.name,
+		resolved: i18nNames.has(node.name) || ALWAYS_I18N.has(node.name)
+	};
+	if (node.type === "MemberExpression") return resolveMemberCallee(node, i18nNames);
+}
+function resolveMemberCallee(node, i18nNames) {
+	if (node.property?.type !== "Identifier") return void 0;
+	const name = node.property.name;
+	const receiverIsI18n = node.object?.type === "Identifier" && i18nNames.has(node.object.name);
+	return {
+		name,
+		resolved: ALWAYS_I18N.has(name) || receiverIsI18n && MAYBE_I18N.has(name)
+	};
+}
+function readArgument$1(node, parsed) {
+	if (node.type === "Literal" && typeof node.value === "string") return {
+		kind: "static",
+		value: node.value
+	};
+	if (node.type === "TemplateLiteral") return readTemplateArgument(node, parsed);
+	if (node.type === "BinaryExpression" && node.operator === "+" && typeof node.left?.value === "string") return {
+		kind: "concat",
+		prefix: node.left.value
+	};
+	return { kind: "unknown" };
+}
+function readTemplateArgument(node, parsed) {
+	if ((node.expressions ?? []).length === 0) {
+		const only = node.quasis?.[0]?.value?.cooked;
+		return typeof only === "string" ? {
+			kind: "static",
+			value: only
+		} : { kind: "unknown" };
+	}
+	const resolved = resolveTemplate(node, parsed.constants);
+	if (resolved !== void 0) return {
+		kind: "static",
+		value: resolved
+	};
+	return {
+		kind: "template",
+		expression: typeof node.start === "number" && typeof node.end === "number" ? parsed.source.slice(node.start + 1, node.end - 1) : (node.quasis ?? []).map((q) => q.value?.cooked ?? "").join("${_}")
+	};
+}
+/**
+* The literal a template resolves to, or undefined when any slot is something
+* other than a constant this file declares.
+*/
+function resolveTemplate(node, constants) {
+	const parts = [];
+	const quasis = node.quasis ?? [];
+	const expressions = node.expressions ?? [];
+	for (const [i, quasi] of quasis.entries()) {
+		parts.push(quasi.value?.cooked ?? "");
+		const expression = expressions[i];
+		if (!expression) continue;
+		if (expression.type !== "Identifier") return void 0;
+		const value = constants.get(expression.name);
+		if (typeof value !== "string") return void 0;
+		parts.push(value);
+	}
+	return parts.join("");
+}
+function calleeName$1(node) {
+	if (!node) return void 0;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "MemberExpression" && node.property?.type === "Identifier") return node.property.name;
+}
+function walk$1(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (typeof node.type === "string") visit(node);
+	for (const [key, child] of Object.entries(node)) {
+		if (SKIP_KEYS.has(key)) continue;
+		walkChild$1(child, visit);
+	}
+}
+/** Positional metadata, not syntax — walking it wastes time and finds nothing. */
+const SKIP_KEYS = new Set([
+	"loc",
+	"range",
+	"parent"
+]);
+function walkChild$1(child, visit) {
+	if (Array.isArray(child)) {
+		for (const item of child) walkChild$1(item, visit);
+		return;
+	}
+	if (child && typeof child === "object") walk$1(child, visit);
+}
+/**
+* Split an SFC into parseable blocks. A template block's expressions are not
+* JavaScript, so its interpolations are lifted out and parsed as expressions —
+* the same trick the PHP frontend uses for Blade directives.
+*/
+function vueBlocks(content) {
+	return [...scriptBlocks(content), ...templateExpressionBlocks(content)];
+}
+const lineOffsetAt = (content, offset) => content.slice(0, offset).split("\n").length - 1;
+function scriptBlocks(content) {
+	const blocks = [];
+	for (const match of content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)) {
+		const openTagLength = match[0].length - (match[1]?.length ?? 0) - 9;
+		blocks.push({
+			source: match[1] ?? "",
+			lineOffset: lineOffsetAt(content, (match.index ?? 0) + openTagLength)
+		});
+	}
+	return blocks;
+}
+function templateExpressionBlocks(content) {
+	const blocks = [];
+	for (const match of content.matchAll(/\{\{([\s\S]*?)\}\}|(?:v-[a-z-]+|:[\w-]+|@[\w-]+)=(?:"([^"]*)"|'([^']*)')/g)) {
+		const expression = match[1] ?? match[2] ?? match[3];
+		if (!expression?.trim()) continue;
+		blocks.push({
+			source: `(${expression})`,
+			lineOffset: lineOffsetAt(content, match.index ?? 0)
+		});
+	}
+	return blocks;
+}
+//#endregion
+//#region src/scanner/frontends/php/index.ts
+/**
+* Laravel PHP, read as syntax (#403, #332).
+*
+* The helpers are global functions, so recognition is by name rather than by
+* following an import — but the *arguments* are read from a real parse:
+* `"statuses.{$status}.label"` is an interpolated string with known parts, not
+* a regex's guess about where the quotes end. Heredocs, escapes and nested
+* quotes come for free.
+*
+* Blade is not read here: templates are lifted to PHP expressions by their own
+* frontend. This one declines `.blade.php`.
+*/
+/** The Laravel translation helpers. Global names; nothing else is called that. */
+const PHP_I18N_CALLEES = new Set([
+	"__",
+	"trans",
+	"trans_choice"
+]);
+function createPhpFrontend() {
+	return {
+		name: "php",
+		handles(filePath) {
+			return filePath.endsWith(".php") && !filePath.endsWith(".blade.php");
+		},
+		async read(content, filePath) {
+			const parser = await loadPhpParser(filePath);
+			if (!parser) return null;
+			let program;
+			try {
+				program = parser.parseCode(content, filePath);
+			} catch (error) {
+				log.debug(`php frontend declined ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+				return null;
+			}
+			return collectPhpSites(program);
+		}
+	};
+}
+/**
+* Call sites in a parsed program. Shared with the Blade frontend, which parses
+* lifted expressions through the same engine and interprets them identically —
+* a key's fate must not depend on which file type referenced it (#332).
+*/
+function collectPhpSites(program, lineOffset = 0, calleeOverride) {
+	const sites = [];
+	walk(program, (node) => {
+		if (node.kind !== "call") return;
+		const callee = calleeName(node.what);
+		if (!callee) return;
+		const [first] = node.arguments ?? [];
+		if (!first) return;
+		sites.push({
+			callee: calleeOverride ?? callee,
+			binding: "resolved",
+			argument: readArgument(first),
+			line: (node.loc?.start?.line ?? 1) + lineOffset
+		});
+	});
+	return sites;
+}
+function calleeName(what) {
+	if (!what) return void 0;
+	if (what.kind === "name" && typeof what.name === "string" && PHP_I18N_CALLEES.has(what.name)) return what.name;
+	return isLangGet(what) ? "Lang::get" : void 0;
+}
+function isLangGet(what) {
+	if (what.kind !== "staticlookup") return false;
+	return what.what?.name === "Lang" && what.offset?.name === "get";
+}
+function readArgument(node) {
+	if ((node.kind === "string" || node.kind === "nowdoc") && typeof node.value === "string") return {
+		kind: "static",
+		value: node.value
+	};
+	if (node.kind === "encapsed" && Array.isArray(node.value)) return readEncapsed(node.value);
+	if (node.kind === "bin" && node.type === ".") return readConcat(node);
+	return { kind: "unknown" };
+}
+/** `'orders.status.' . $status` — the literal side bounds what the call can produce. */
+function readConcat(node) {
+	const left = node.left;
+	if (left?.kind === "string" && typeof left.value === "string") return {
+		kind: "concat",
+		prefix: left.value
+	};
+	return { kind: "unknown" };
+}
+/**
+* Double-quoted or heredoc string with interpolation: known literal parts
+* around `${_}` slots — or a plain string after all, when nothing
+* interpolates.
+*/
+function readEncapsed(parts) {
+	const rendered = parts.map((part) => {
+		const expression = part.expression;
+		return expression?.kind === "string" && typeof expression.value === "string" ? expression.value : "${_}";
+	}).join("");
+	return rendered.includes("${_}") ? {
+		kind: "template",
+		expression: rendered
+	} : {
+		kind: "static",
+		value: rendered
+	};
+}
+const parserPromises = /* @__PURE__ */ new Map();
+function loadPhpParser(fromFile) {
+	const key = dirname(fromFile);
+	let promise = parserPromises.get(key);
+	if (!promise) {
+		promise = resolveParser(fromFile);
+		parserPromises.set(key, promise);
+	}
+	return promise;
+}
+let warnedMissingParser = false;
+async function resolveParser(fromFile) {
+	const Engine = requireFromProject(fromFile) ?? await importFromOwnTree();
+	if (!Engine) {
+		if (warnedMissingParser) return null;
+		warnedMissingParser = true;
+		log.warn("PHP files found, but php-parser is not installed — falling back to pattern matching. Laravel projects need the PHP packages installed: npm i -D php-parser php-array-reader");
+		return null;
+	}
+	return new Engine({
+		parser: {
+			php7: true,
+			suppressErrors: false
+		},
+		ast: { withPositions: true }
+	});
+}
+function requireFromProject(fromFile) {
+	try {
+		return createRequire(isAbsolute(fromFile) ? fromFile : join(process.cwd(), fromFile))("php-parser");
+	} catch {
+		return;
+	}
+}
+async function importFromOwnTree() {
+	try {
+		const mod = await import("php-parser");
+		return mod.default ?? mod;
+	} catch {
+		return;
+	}
+}
+function walk(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (typeof node.kind === "string") visit(node);
+	for (const [key, child] of Object.entries(node)) {
+		if (key === "loc" || key === "parent") continue;
+		walkChild(child, visit);
+	}
+}
+function walkChild(child, visit) {
+	if (Array.isArray(child)) {
+		for (const item of child) walkChild(item, visit);
+		return;
+	}
+	if (child && typeof child === "object") walk(child, visit);
+}
 const LARAVEL_PATTERNS = {
 	label: "Laravel",
 	filePatterns: ["**/*.blade.php", "**/*.php"],
@@ -4062,163 +4562,438 @@ const LARAVEL_PATTERNS = {
 	bareShapes: "php"
 };
 /**
-* Maps locale file format to the appropriate scan pattern set.
-* 'php-array' → Laravel (PHP translation helpers in Blade/PHP files).
-* 'json' / undefined → Vue/Nuxt ($t / t calls in Vue/TS/JS files).
+* Matches PHP double-quoted interpolated strings with i18n-key shape,
+* regardless of call context — `$transKey = "api.x.{$key}"` assigned first
+* and passed to Lang::get() later must still suppress api.x.* orphans.
+* Content is restricted to key-like chars plus {$expr} / $var->prop
+* interpolations: a permissive "any double-quoted string containing $"
+* match swallows the code BETWEEN quoted strings (PHP code is full of $),
+* shifting quote parity past the real candidates.
 */
-function getPatternSet(format) {
-	switch (format) {
-		case "php-array": return LARAVEL_PATTERNS;
-		default: return VUE_NUXT_PATTERNS;
+const BARE_PHP_DYNAMIC = /"((?:[\w.-]|\{\$[^}]+\}|\$[a-zA-Z_][a-zA-Z0-9_]*(?:->[a-zA-Z_][a-zA-Z0-9_]*)*)+)"/g;
+function collectBarePhpCandidates(content, bareDynamics) {
+	BARE_PHP_DYNAMIC.lastIndex = 0;
+	for (const match of content.matchAll(BARE_PHP_DYNAMIC)) {
+		const expr = match[1];
+		if (!expr?.includes("$")) continue;
+		const normalized = expr.replace(/\{\$[^}]+\}/g, "${_}").replace(/\$[a-zA-Z_][a-zA-Z0-9_]*(?:->[a-zA-Z_][a-zA-Z0-9_]*)*/g, "${_}");
+		if (!normalized.replace(/\$\{_\}/g, "").includes(".")) continue;
+		bareDynamics.add(`\`${normalized}\``);
 	}
 }
 //#endregion
-//#region src/scanner/code-scanner.ts
+//#region src/scanner/frontends/php/blade.ts
 /**
-* Matches `const` declarations initialized to a key-shaped string literal
-* (≥1 dot). Scope is deliberately tight: identifier = literal only — no
-* object properties, no expressions, and no `let` (a reassigned binding
-* would substitute a stale literal and bypass the conservative widening).
-*/
-const CONST_KEY_DECL = /\bconst\s+([A-Za-z_$][\w$]*)\s*=\s*(['"])((?:[\w-]+\.)+[\w-]+)\2/g;
-/**
-* Collects same-file `const NAME = 'dotted.path'` declarations so
-* `${NAME}` interpolations can be substituted with the literal value.
-* Same-file only — imported/cross-file constants are NOT resolved and fall
-* back to the conservative `${_}` widening in buildDynamicKeyRegexes.
-* A name bound to different values (shadowing across scopes) is ambiguous
-* and dropped: substituting one of several possible values could narrow a
-* pattern past a live key.
+* Blade, by lifting (#404, #332).
+*
+* No maintained Blade AST parser exists, and none is needed: every construct
+* that can carry a translation key wraps a PHP expression. The lexical pass
+* here finds those wrappers — echoes, `@lang`/`@choice`, `@php` blocks, raw
+* PHP tags — and hands the expression inside to the same parser and the same
+* site collection plain PHP uses. The regex frames text; it never decides
+* what a key is.
+*
+* A lifted chunk the parser cannot read declines the whole file to the
+* pattern fallback: partially-read templates would silently drop keys.
 */
-function collectConstKeyTable(content) {
-	const table = /* @__PURE__ */ new Map();
-	const ambiguous = /* @__PURE__ */ new Set();
-	CONST_KEY_DECL.lastIndex = 0;
-	for (const match of content.matchAll(CONST_KEY_DECL)) {
-		const name = match[1];
-		const value = match[3];
-		if (!name || !value || ambiguous.has(name)) continue;
-		const existing = table.get(name);
-		if (existing !== void 0 && existing !== value) {
-			table.delete(name);
-			ambiguous.add(name);
-			continue;
+function createBladeFrontend() {
+	return {
+		name: "blade",
+		handles(filePath) {
+			return filePath.endsWith(".blade.php");
+		},
+		async read(content, filePath) {
+			const parser = await loadPhpParser(filePath);
+			if (!parser) return null;
+			const sites = [];
+			for (const chunk of liftChunks(content)) {
+				const parsed = parseChunk(parser, chunk, filePath);
+				if (!parsed) {
+					if (chunk.optional) continue;
+					return null;
+				}
+				sites.push(...collectPhpSites(parsed, chunk.lineOffset, chunk.callee));
+			}
+			sites.sort((a, b) => a.line - b.line);
+			return sites;
 		}
-		table.set(name, value);
+	};
+}
+function parseChunk(parser, chunk, filePath) {
+	try {
+		return parser.parseCode(`<?php ${chunk.source}`, filePath);
+	} catch (error) {
+		log.debug(`blade frontend declined ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+		return null;
 	}
-	return table;
 }
-/**
-* Substitutes `${NAME}` interpolations with the const table's literal value,
-* producing an exact or narrower pattern: `${i18nBase}.title` +
-* `const i18nBase = 'a.b.c'` → `a.b.c.title`. Only plain-identifier
-* interpolations qualify; member expressions and anything else stay dynamic.
-*/
-function substituteConstIdentifiers(expr, table) {
-	if (table.size === 0 || !expr.includes("${")) return expr;
-	return expr.replace(/\$\{\s*([A-Za-z_$][\w$]*)\s*\}/g, (whole, name) => table.get(name) ?? whole);
+const BLADE_COMMENT = /\{\{--[\s\S]*?--\}\}/g;
+function liftChunks(content) {
+	const source = content.replace(BLADE_COMMENT, (m) => m.replace(/[^\n]/g, " "));
+	const lineAt = (offset) => source.slice(0, offset).split("\n").length - 1;
+	return [
+		...echoChunks(source, lineAt),
+		...phpBlockChunks(source, lineAt),
+		...boundAttributeChunks(source, lineAt),
+		...directiveChunks(source, lineAt)
+	];
 }
-function extractStaticMatches(line, lineNumber, ctx) {
-	for (const regex of ctx.pat.staticKeyPatterns) {
-		regex.lastIndex = 0;
-		for (const match of line.matchAll(regex)) {
-			const callee = match[1] ?? "";
-			const key = match[3];
-			if (!key) continue;
-			if (key.includes("{$")) continue;
-			if (ctx.pat.requiresDotForCallee?.(callee) && !key.includes(".")) {
-				ctx.bareCandidates.add(key);
-				continue;
-			}
-			ctx.usages.push({
-				key,
-				file: ctx.filePath,
-				line: lineNumber,
-				callee
-			});
-		}
+/** {{ expr }} and {!! expr !!} — echoes of a PHP expression. */
+function echoChunks(source, lineAt) {
+	return expressionChunks(source, /\{\{([\s\S]*?)\}\}|\{!!([\s\S]*?)!!\}/g, lineAt, (expression) => ({ source: `${expression};` }));
+}
+function expressionChunks(source, pattern, lineAt, shape) {
+	const chunks = [];
+	for (const match of source.matchAll(pattern)) {
+		const expression = match[1] ?? match[2];
+		if (!expression?.trim()) continue;
+		chunks.push({
+			...shape(expression),
+			lineOffset: lineAt(match.index ?? 0)
+		});
+	}
+	return chunks;
+}
+/** @php ... @endphp and raw <?php ... ?> — statements as written. */
+function phpBlockChunks(source, lineAt) {
+	return [...bodyChunks(source, /@php\b(?!\s*\()([\s\S]*?)@endphp/g, lineAt), ...bodyChunks(source, /<\?php\b([\s\S]*?)(?:\?>|$)/g, lineAt)];
+}
+function bodyChunks(source, pattern, lineAt) {
+	const chunks = [];
+	for (const match of source.matchAll(pattern)) {
+		const body = match[1];
+		if (body?.trim()) chunks.push({
+			source: body,
+			lineOffset: lineAt(match.index ?? 0)
+		});
 	}
+	return chunks;
 }
 /**
-* Normalizes every interpolation syntax (JS `${expr}`, PHP `{$expr}` and
-* bare `$var->prop`) to `${_}` slots. Returns undefined when the expression
-* contains no interpolation at all.
+* Bound component attributes — :message="__('alerts.saved')" compiles to a
+* PHP expression. `::` escapes to a literal colon and carries none.
 */
-function normalizeDynamicExpression(expression) {
-	const hasDollarBrace = expression.includes("${");
-	const hasBraceDollar = expression.includes("{$");
-	const hasBarePHP = !hasDollarBrace && !hasBraceDollar && /\$[a-zA-Z_]/.test(expression);
-	if (!hasDollarBrace && !hasBraceDollar && !hasBarePHP) return void 0;
-	return hasBraceDollar ? expression.replace(/\{\$[^}]+\}/g, "${_}") : hasBarePHP ? expression.replace(/\$[a-zA-Z_][a-zA-Z0-9_]*(?:->[a-zA-Z_][a-zA-Z0-9_]*)*/g, "${_}") : expression;
+function boundAttributeChunks(source, lineAt) {
+	return expressionChunks(source, /(?<![:\w]):[\w-]+=(?:"([^"]*)"|'([^']*)')/g, lineAt, (expression) => ({
+		source: `__args__(${expression});`,
+		optional: true
+	}));
+}
+/**
+* Directive arguments. @lang and @choice are thin wrappers over __ and
+* trans_choice — the argument list is the translation call, reported under
+* the directive's own name. Every other directive gets its arguments read
+* as an expression list (`@section('title', __('Forbidden'))` carries a
+* real call), best-effort: what is not an expression is Blade grammar.
+* The inline @php($x = ...) form is an expression list like any other.
+*/
+function directiveChunks(source, lineAt) {
+	const chunks = [];
+	for (const match of source.matchAll(/@(\w+)\s*\(/g)) {
+		const args = balancedParens(source, (match.index ?? 0) + match[0].length - 1);
+		if (args === void 0) continue;
+		const chunk = directiveChunk(match[1] ?? "", args, lineAt(match.index ?? 0));
+		if (chunk) chunks.push(chunk);
+	}
+	return chunks;
+}
+function directiveChunk(directive, args, lineOffset) {
+	if (directive === "lang" || directive === "choice") return {
+		source: `${directive === "lang" ? "__" : "trans_choice"}(${args});`,
+		lineOffset,
+		callee: `@${directive}`
+	};
+	return args.trim() ? {
+		source: `__args__(${args});`,
+		lineOffset,
+		optional: true
+	} : void 0;
+}
+/**
+* The argument text between a directive's parentheses, quote-aware — a `)`
+* inside a string does not close the call. Returns undefined when the call
+* never closes, which declines the construct rather than guessing.
+*/
+function balancedParens(source, openIndex) {
+	let depth = 0;
+	for (let i = openIndex; i < source.length; i++) {
+		const ch = source[i];
+		if (ch === "'" || ch === "\"") i = skipString(source, i);
+		else if (ch === "(") depth++;
+		else if (ch === ")" && --depth === 0) return source.slice(openIndex + 1, i);
+	}
+}
+/** The index of a string literal's closing quote, escapes respected. */
+function skipString(source, start) {
+	const quote = source[start];
+	for (let i = start + 1; i < source.length; i++) if (source[i] === "\\") i++;
+	else if (source[i] === quote) return i;
+	return source.length;
+}
+//#endregion
+//#region src/scanner/rules.ts
+/**
+* The one callee whose dotless arguments are not evidence: a bare `t` is what
+* `emit`, test helpers and local functions are also called. Every other name
+* the pattern sets match (`$t`, `__`, `trans`, ...) is distinctive enough that
+* its argument counts, dot or no dot. Formerly per-pattern-set configuration;
+* it is a rule about meaning, so it lives with the rules.
+*/
+const ambiguousCalleeNeedsDot = (callee) => callee === "t";
+function interpret(sites, ctx) {
+	const usages = [];
+	const dynamicKeys = [];
+	const bareStringCandidates = /* @__PURE__ */ new Set();
+	for (const site of sites) {
+		const { callee, line, argument } = site;
+		const guarded = site.binding === "ambiguous" && ctx.ambiguousCalleeNeedsDot(callee);
+		switch (argument.kind) {
+			case "static":
+				if (guarded && !argument.value.includes(".")) {
+					bareStringCandidates.add(argument.value);
+					break;
+				}
+				usages.push({
+					key: argument.value,
+					file: ctx.filePath,
+					line,
+					callee
+				});
+				break;
+			case "template":
+				dynamicKeys.push({
+					expression: `\`${argument.expression}\``,
+					file: ctx.filePath,
+					line,
+					callee
+				});
+				break;
+			case "concat":
+				if (guarded && !argument.prefix.includes(".")) break;
+				dynamicKeys.push({
+					expression: `\`${argument.prefix}\${_}\``,
+					file: ctx.filePath,
+					line,
+					callee
+				});
+				break;
+			case "unknown": break;
+		}
+	}
+	return {
+		usages,
+		dynamicKeys,
+		bareStringCandidates
+	};
+}
+//#endregion
+//#region src/scanner/frontends/patterns.ts
+/**
+* The regex path as a language frontend (#332).
+*
+* Regexes frame text and report call sites; what a site means is decided once,
+* in the rules, the same as for every other frontend. Binding is always
+* `ambiguous`, because a regex can never prove what a name is bound to — which
+* is the entire reason the syntax frontends exist.
+*
+* This frontend never declines: it is the floor every scan can fall back to.
+*/
+function createPatternsFrontend(pat) {
+	return {
+		name: "patterns",
+		handles: () => true,
+		read: (content, filePath) => Promise.resolve(readPatternSites(content, filePath, pat))
+	};
+}
+/**
+* Synchronous core, so the sync `extractKeys` contract the scanner suites are
+* written against keeps working unchanged.
+*/
+function readPatternSites(content, _filePath, pat) {
+	const sites = [];
+	const seen = /* @__PURE__ */ new Set();
+	const lines = content.split("\n");
+	for (const [i, line] of lines.entries()) {
+		const lineNumber = i + 1;
+		staticSites(line, lineNumber, pat, sites, seen);
+		dynamicSites(line, lineNumber, pat, sites, seen);
+		concatSites(line, lineNumber, pat, sites);
+	}
+	return sites;
+}
+function pushStatic(sites, seen, callee, value, line) {
+	const id = `${line}:${callee}:${value}`;
+	if (seen.has(id)) return;
+	seen.add(id);
+	sites.push({
+		callee,
+		binding: "ambiguous",
+		argument: {
+			kind: "static",
+			value
+		},
+		line
+	});
 }
-function extractDynamicMatches(line, lineNumber, ctx) {
-	for (const regex of ctx.pat.dynamicKeyPatterns) {
+function staticSites(line, lineNumber, pat, sites, seen) {
+	for (const regex of pat.staticKeyPatterns) {
+		regex.lastIndex = 0;
+		for (const match of line.matchAll(regex)) {
+			const callee = match[1] ?? "";
+			const key = match[3];
+			if (!key) continue;
+			if (key.includes("{$")) continue;
+			pushStatic(sites, seen, callee, key, lineNumber);
+		}
+	}
+}
+function dynamicSites(line, lineNumber, pat, sites, seen) {
+	for (const regex of pat.dynamicKeyPatterns) {
 		regex.lastIndex = 0;
 		for (const match of line.matchAll(regex)) {
 			const callee = match[1] ?? "";
 			const raw = match[2];
 			if (!raw) continue;
-			const expression = substituteConstIdentifiers(raw, ctx.constTable);
-			const normalized = normalizeDynamicExpression(expression);
+			const normalized = normalizeDynamicExpression(raw);
 			if (normalized === void 0) {
-				if (!ctx.pat.promoteStaticDynamicMatches) continue;
-				if (!expression) continue;
-				if (ctx.pat.requiresDotForCallee?.(callee) && !expression.includes(".")) continue;
-				ctx.usages.push({
-					key: expression,
-					file: ctx.filePath,
-					line: lineNumber,
-					callee
-				});
+				pushStatic(sites, seen, callee, raw, lineNumber);
 				continue;
 			}
-			ctx.dynamicKeys.push({
-				expression: `\`${normalized}\``,
-				file: ctx.filePath,
-				line: lineNumber,
-				callee
+			sites.push({
+				callee,
+				binding: "ambiguous",
+				argument: {
+					kind: "template",
+					expression: normalized
+				},
+				line: lineNumber
 			});
 		}
 	}
 }
-function extractConcatMatches(line, lineNumber, ctx) {
-	for (const regex of ctx.pat.concatKeyPatterns) {
+function concatSites(line, lineNumber, pat, sites) {
+	for (const regex of pat.concatKeyPatterns) {
 		regex.lastIndex = 0;
 		for (const match of line.matchAll(regex)) {
 			const callee = match[1] ?? "";
 			const prefix = match[3];
 			if (!prefix) continue;
-			if (ctx.pat.requiresDotForCallee?.(callee) && !prefix.includes(".")) continue;
-			ctx.dynamicKeys.push({
-				expression: `\`${prefix}\${_}\``,
-				file: ctx.filePath,
-				line: lineNumber,
-				callee
+			sites.push({
+				callee,
+				binding: "ambiguous",
+				argument: {
+					kind: "concat",
+					prefix
+				},
+				line: lineNumber
 			});
 		}
 	}
 }
-function extractKeys(content, filePath, patterns, constTable) {
-	const pat = patterns ?? VUE_NUXT_PATTERNS;
-	const ctx = {
-		pat,
-		constTable: constTable ?? (pat.resolveLocalConsts ? collectConstKeyTable(content) : /* @__PURE__ */ new Map()),
-		filePath,
-		usages: [],
-		dynamicKeys: [],
-		bareCandidates: /* @__PURE__ */ new Set()
-	};
-	const lines = content.split("\n");
-	for (const [i, line] of lines.entries()) {
-		const lineNumber = i + 1;
-		extractStaticMatches(line, lineNumber, ctx);
-		extractDynamicMatches(line, lineNumber, ctx);
-		extractConcatMatches(line, lineNumber, ctx);
+/**
+* Matches `const` declarations initialized to a key-shaped string literal
+* (>=1 dot). Scope is deliberately tight: identifier = literal only — no
+* object properties, no expressions, and no `let` (a reassigned binding
+* would substitute a stale literal and bypass the conservative widening).
+*/
+const CONST_KEY_DECL = /\bconst\s+([A-Za-z_$][\w$]*)\s*=\s*(['"])((?:[\w-]+\.)+[\w-]+)\2/g;
+/**
+* Collects same-file `const NAME = 'dotted.path'` declarations for the
+* bare-candidate net, which stays deliberately non-syntactic (#332): a
+* substituted candidate is an exact protector where an unsubstituted one
+* would be a wildcard. Usage extraction no longer consults this — the syntax
+* frontends resolve real bindings instead.
+*/
+function collectConstKeyTable(content) {
+	const table = /* @__PURE__ */ new Map();
+	const ambiguous = /* @__PURE__ */ new Set();
+	CONST_KEY_DECL.lastIndex = 0;
+	for (const match of content.matchAll(CONST_KEY_DECL)) {
+		const name = match[1];
+		const value = match[3];
+		if (!name || !value || ambiguous.has(name)) continue;
+		const existing = table.get(name);
+		if (existing !== void 0 && existing !== value) {
+			table.delete(name);
+			ambiguous.add(name);
+			continue;
+		}
+		table.set(name, value);
+	}
+	return table;
+}
+/**
+* Substitutes `${NAME}` interpolations with the const table's literal value,
+* producing an exact or narrower pattern: `${i18nBase}.title` +
+* `const i18nBase = 'a.b.c'` -> `a.b.c.title`. Only plain-identifier
+* interpolations qualify; member expressions and anything else stay dynamic.
+*/
+function substituteConstIdentifiers(expr, table) {
+	if (table.size === 0 || !expr.includes("${")) return expr;
+	return expr.replace(/\$\{\s*([A-Za-z_$][\w$]*)\s*\}/g, (whole, name) => table.get(name) ?? whole);
+}
+/**
+* Normalizes every interpolation syntax (JS `${expr}`, PHP `{$expr}` and
+* bare `$var->prop`) to `${_}` slots. Returns undefined when the expression
+* contains no interpolation at all.
+*/
+function normalizeDynamicExpression(expression) {
+	const hasDollarBrace = expression.includes("${");
+	const hasBraceDollar = expression.includes("{$");
+	const hasBarePHP = !hasDollarBrace && !hasBraceDollar && /\$[a-zA-Z_]/.test(expression);
+	if (!hasDollarBrace && !hasBraceDollar && !hasBarePHP) return void 0;
+	return hasBraceDollar ? expression.replace(/\{\$[^}]+\}/g, "${_}") : hasBarePHP ? expression.replace(/\$[a-zA-Z_][a-zA-Z0-9_]*(?:->[a-zA-Z_][a-zA-Z0-9_]*)*/g, "${_}") : expression;
+}
+const VUE_NUXT_PATTERNS = {
+	label: "Vue / Nuxt",
+	filePatterns: [
+		"**/*.vue",
+		"**/*.ts",
+		"**/*.tsx",
+		"**/*.js",
+		"**/*.jsx",
+		"**/*.mjs",
+		"**/*.mts"
+	],
+	ignoreDirs: [
+		"node_modules",
+		".nuxt",
+		".output",
+		"dist",
+		".git",
+		"coverage",
+		".tmp"
+	],
+	staticKeyPatterns: [/(?<!\w)(this\.\$te?|\$te?|\bt)\s*\(\s*(['"])((?:(?!\2).)*)\2/g],
+	dynamicKeyPatterns: [/(?<!\w)(this\.\$te?|\$te?|\bt)\s*\(\s*`((?:[^`]|\\.)*)`/g],
+	concatKeyPatterns: [/(?<!\w)(this\.\$te?|\$te?|\bt)\s*\(\s*(['"])((?:(?!\2).)*)\2\s*\+/g],
+	bareShapes: "js"
+};
+/**
+* Maps locale file format to the appropriate scan pattern set.
+* 'php-array' → Laravel (PHP translation helpers in Blade/PHP files).
+* 'json' / undefined → Vue/Nuxt ($t / t calls in Vue/TS/JS files).
+*/
+function getPatternSet(format) {
+	switch (format) {
+		case "php-array": return LARAVEL_PATTERNS;
+		default: return VUE_NUXT_PATTERNS;
 	}
+}
+//#endregion
+//#region src/scanner/code-scanner.ts
+/**
+* One file's evidence through the pattern frontend — the sync contract the
+* scanner suites are written against. Same pipeline as every scan: the
+* frontend reports call sites, the rules decide what they mean.
+*/
+function extractKeys(content, filePath, patterns) {
+	return interpret(readPatternSites(content, filePath, patterns ?? VUE_NUXT_PATTERNS), ruleContext(filePath));
+}
+function ruleContext(filePath) {
 	return {
-		usages: ctx.usages,
-		dynamicKeys: ctx.dynamicKeys,
-		bareStringCandidates: ctx.bareCandidates
+		filePath,
+		ambiguousCalleeNeedsDot
 	};
 }
 /**
@@ -4315,16 +5090,6 @@ const BARE_DYNAMIC_TEMPLATE = /`([\w.-]*(?:\$\{(?:[^`{}\n]|\{[^`{}\n]*\})*\}[\w.
 /** Longer candidates cannot plausibly be i18n keys — drop, don't truncate. */
 const MAX_BARE_TEMPLATE_LENGTH = 120;
 /**
-* Matches PHP double-quoted interpolated strings with i18n-key shape,
-* regardless of call context — `$transKey = "api.x.{$key}"` assigned first
-* and passed to Lang::get() later must still suppress api.x.* orphans.
-* Content is restricted to key-like chars plus {$expr} / $var->prop
-* interpolations: a permissive "any double-quoted string containing $"
-* match swallows the code BETWEEN quoted strings (PHP code is full of $),
-* shifting quote parity past the real candidates.
-*/
-const BARE_PHP_DYNAMIC = /"((?:[\w.-]|\{\$[^}]+\}|\$[a-zA-Z_][a-zA-Z0-9_]*(?:->[a-zA-Z_][a-zA-Z0-9_]*)*)+)"/g;
-/**
 * Matches prefix-shaped string literals (≥1 key-like segment, trailing dot,
 * closing quote right after the dot) regardless of call context: concat
 * prefixes ('menu.' + var, __('a.b.' . $x) — incl. multiline t() calls where
@@ -4362,16 +5127,6 @@ function collectBareTemplateCandidates(content, constTable, bareStrings, bareDyn
 		bareDynamics.add(`\`${normalized}\``);
 	}
 }
-function collectBarePhpCandidates(content, bareDynamics) {
-	BARE_PHP_DYNAMIC.lastIndex = 0;
-	for (const match of content.matchAll(BARE_PHP_DYNAMIC)) {
-		const expr = match[1];
-		if (!expr?.includes("$")) continue;
-		const normalized = expr.replace(/\{\$[^}]+\}/g, "${_}").replace(/\$[a-zA-Z_][a-zA-Z0-9_]*(?:->[a-zA-Z_][a-zA-Z0-9_]*)*/g, "${_}");
-		if (!normalized.replace(/\$\{_\}/g, "").includes(".")) continue;
-		bareDynamics.add(`\`${normalized}\``);
-	}
-}
 function collectBarePrefixCandidates(content, bareDynamics) {
 	BARE_PREFIX_LITERAL.lastIndex = 0;
 	for (const match of content.matchAll(BARE_PREFIX_LITERAL)) bareDynamics.add(`\`${match[2]}\${_}\``);
@@ -4417,8 +5172,69 @@ function collectBareCandidates(content, constTable, bareStrings, bareDynamics, b
 *
 * When `patterns` is omitted, defaults to Vue/Nuxt patterns.
 */
-async function scanSourceFiles(rootDir, excludeDirs, patterns) {
+/**
+* One file's evidence, preferring a frontend that reads the language as syntax
+* over one that matches it as text (#332).
+*
+* A frontend that declines — an unparseable file, a parser that would not load
+* — falls through to pattern matching rather than failing. Better evidence when
+* it is available, never a scan that stops because it was not.
+*/
+async function extractFileEvidence(content, filePath, frontends, patterns) {
+	const pat = patterns ?? VUE_NUXT_PATTERNS;
+	let declined = false;
+	for (const frontend of frontends) {
+		if (!frontend.handles(filePath)) continue;
+		const sites = await frontend.read(content, filePath);
+		if (!sites) {
+			declined = true;
+			continue;
+		}
+		return {
+			...interpret(sites, ruleContext(filePath)),
+			declined
+		};
+	}
+	return {
+		...extractKeys(content, filePath, pat),
+		declined
+	};
+}
+/**
+* Opt-in, via `I18N_SCANNER=ast`.
+*
+* The architecture is settled; the migration is not. #332 gates each frontend
+* on a differential run showing it is at least as conservative as what it
+* replaces, and on anny-ui the AST frontend still misses 13 keys the patterns
+* find — most of them regex artifacts, a handful genuine. A key the outgoing
+* frontend saw and the incoming one does not becomes an orphan, and orphans
+* get deleted, so the default stays where the evidence is.
+*
+* Flip it once `scripts/scanner-diff.mjs` reports nothing in that direction.
+*/
+let warnedRegexHatch = false;
+/**
+* The syntax frontends are the default (#402 for JS/TS/Vue, #405 for
+* PHP/Blade); patterns read only what they decline. `I18N_SCANNER=regex`
+* restores the old scanner for exactly one release — an escape hatch for
+* reporting a regression, not a mode.
+*/
+function defaultFrontends(pat) {
+	if (process.env.I18N_SCANNER === "regex") {
+		if (!warnedRegexHatch) {
+			warnedRegexHatch = true;
+			log.warn("I18N_SCANNER=regex is deprecated and will be removed in the next major. If the default scanner misses something the regex found, please file it: https://github.com/fabkho/the-i18n-kit/issues");
+		}
+		return [createPatternsFrontend(pat)];
+	}
+	return [...pat.bareShapes === "php" ? [phpFrontend, bladeFrontend] : [oxcFrontend], createPatternsFrontend(pat)];
+}
+const oxcFrontend = createOxcFrontend();
+const phpFrontend = createPhpFrontend();
+const bladeFrontend = createBladeFrontend();
+async function scanSourceFiles(rootDir, excludeDirs, patterns, frontends) {
 	const pat = patterns ?? VUE_NUXT_PATTERNS;
+	const active = frontends ?? defaultFrontends(pat);
 	const ignore = [...pat.ignoreDirs, ...excludeDirs ?? []];
 	let relativePaths;
 	try {
@@ -4433,6 +5249,7 @@ async function scanSourceFiles(rootDir, excludeDirs, patterns) {
 			usages: [],
 			dynamicKeys: [],
 			filesScanned: 0,
+			declinedFiles: [],
 			uniqueKeys: /* @__PURE__ */ new Set(),
 			bareStringCandidates: /* @__PURE__ */ new Set(),
 			bareDynamicCandidates: /* @__PURE__ */ new Set()
@@ -4442,6 +5259,7 @@ async function scanSourceFiles(rootDir, excludeDirs, patterns) {
 	const allDynamicKeys = [];
 	const bareStringCandidates = /* @__PURE__ */ new Set();
 	const bareDynamicCandidates = /* @__PURE__ */ new Set();
+	const declinedFiles = [];
 	let filesScanned = 0;
 	for (const relPath of relativePaths) {
 		const filePath = join(rootDir, relPath);
@@ -4452,8 +5270,9 @@ async function scanSourceFiles(rootDir, excludeDirs, patterns) {
 			log.warn(`Failed to read file: ${filePath}`);
 			continue;
 		}
-		const constTable = pat.resolveLocalConsts ? collectConstKeyTable(content) : /* @__PURE__ */ new Map();
-		const { usages, dynamicKeys, bareStringCandidates: bareFromCalls } = extractKeys(content, filePath, pat, constTable);
+		const constTable = (pat.bareShapes ?? "js") === "js" ? collectConstKeyTable(content) : /* @__PURE__ */ new Map();
+		const { usages, dynamicKeys, bareStringCandidates: bareFromCalls, declined } = await extractFileEvidence(content, filePath, active, pat);
+		if (declined) declinedFiles.push(relPath);
 		allUsages.push(...usages);
 		allDynamicKeys.push(...dynamicKeys);
 		for (const candidate of bareFromCalls) bareStringCandidates.add(candidate);
@@ -4466,6 +5285,7 @@ async function scanSourceFiles(rootDir, excludeDirs, patterns) {
 		usages: allUsages,
 		dynamicKeys: allDynamicKeys,
 		filesScanned,
+		declinedFiles,
 		uniqueKeys,
 		bareStringCandidates,
 		bareDynamicCandidates
@@ -4530,10 +5350,12 @@ async function findOrphanKeysForConfig(options) {
 	const evidences = [];
 	const allDynamicKeysRaw = [];
 	let totalFilesScanned = 0;
+	let totalFilesDeclined = 0;
 	for (const unit of units) {
 		const ignores = globalScope ? [] : nestedUnitIgnores(unit, units);
 		const result = await scanSourceFiles(unit.dir, [...excludeDirs ?? [], ...ignores], patterns);
 		totalFilesScanned += result.filesScanned;
+		totalFilesDeclined += result.declinedFiles.length;
 		const dynamicRaw = [...result.dynamicKeys, ...[...result.bareDynamicCandidates].map((bd) => ({
 			expression: bd,
 			file: "",
@@ -4578,6 +5400,8 @@ async function findOrphanKeysForConfig(options) {
 	const unitDynRegexes = (evidence) => evidence.dynRegexes ??= buildDynamicKeyRegexes(evidence.dynamicRaw);
 	const orphansByLayer = {};
 	let orphanCount = 0;
+	const candidateOnlyByLayer = {};
+	let candidateOnlyCount = 0;
 	const uncertainByLayer = {};
 	let uncertainCount = 0;
 	let dynamicMatchedCount = 0;
@@ -4592,9 +5416,13 @@ async function findOrphanKeysForConfig(options) {
 		const outOfScope = globalScope ? [] : evidences.filter((e) => !scopeNameSet.has(e.unit.name));
 		const ignorePatterns = resolveIgnorePatterns(layerName);
 		const ignoreRegexes = ignorePatterns ? buildIgnorePatternRegexes(ignorePatterns) : [];
+		const candidateOnly = [];
 		const orphans = keys.filter((k) => {
 			if (scope.unique.has(k)) return false;
-			if (scope.bare.has(k)) return false;
+			if (scope.bare.has(k)) {
+				if (!scope.dynRegexes.some((re) => re.test(k))) candidateOnly.push(k);
+				return false;
+			}
 			if (scope.dynRegexes.some((re) => re.test(k))) {
 				dynamicMatchedCount++;
 				return false;
@@ -4628,6 +5456,10 @@ async function findOrphanKeysForConfig(options) {
 			uncertainByLayer[layerName] = uncertain;
 			uncertainCount += uncertain.length;
 		}
+		if (candidateOnly.length > 0) {
+			candidateOnlyByLayer[layerName] = candidateOnly.sort();
+			candidateOnlyCount += candidateOnly.length;
+		}
 	}
 	misplacedUsages.sort((a, b) => a.layer.localeCompare(b.layer) || a.key.localeCompare(b.key));
 	const byLocation = (a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.expression.localeCompare(b.expression);
@@ -4638,7 +5470,10 @@ async function findOrphanKeysForConfig(options) {
 		orphanCount,
 		uncertainByLayer,
 		uncertainCount,
+		candidateOnlyByLayer,
+		candidateOnlyCount,
 		totalFilesScanned,
+		totalFilesDeclined,
 		dynamicMatchedCount,
 		ignoredCount,
 		allDynamicKeys: allDynamicKeysRaw,
@@ -5099,6 +5934,147 @@ async function scaffoldLocaleFiles(opts) {
 		dryRun: opts.dryRun ?? false
 	};
 }
+/**
+* Move a key from one layer to another, carrying every locale that defines it.
+*
+* Promoting an app-layer key to the shared layer once a second app needs it is
+* a first-class operation in a layered monorepo, and composing it out of
+* get/write/remove is three calls across up to thirty locales with no way to
+* fail cleanly: a truncation between the write and the remove leaves the key in
+* both layers, which is the state `find_duplicate_keys` exists to flag (#341).
+*
+* So the whole move is planned before anything is written. A target that
+* already holds a *different* value is a conflict, and one conflict in one
+* locale writes nothing at all — a half-moved key across thirty files is worse
+* than a refusal. A target already holding the *same* value is not a conflict
+* but a duplicate the move resolves: the source copy is dropped and the locale
+* is reported as deduplicated.
+*
+* Locales come from the resolved config rather than from caller-supplied refs,
+* so there is no ref to leave unresolved (#301) — a locale the source layer
+* does not define is reported in `notFoundInLocales` rather than skipped
+* silently.
+*/
+async function moveTranslationKey(opts) {
+	const { fromLayer, toLayer, key } = opts;
+	const targetKey = opts.newKey ?? key;
+	const config = await detectI18nConfig(opts.projectDir ?? process.cwd());
+	if (fromLayer === toLayer) throw new ToolError(`fromLayer and toLayer are both "${fromLayer}". To rename a key within one layer, use rename_translation_key.`, "SAME_LAYER");
+	findWritableLayerOrThrow(config, fromLayer);
+	findWritableLayerOrThrow(config, toLayer);
+	const { plan, notFound, conflicts } = await planMove(config, {
+		fromLayer,
+		toLayer,
+		key,
+		targetKey
+	});
+	const identity = {
+		fromLayer,
+		toLayer,
+		key,
+		...opts.newKey ? { newKey: opts.newKey } : {},
+		...notFound.length > 0 ? { notFoundInLocales: notFound } : {}
+	};
+	if (conflicts.length > 0) return {
+		...identity,
+		conflictsInLocales: conflicts,
+		summary: {
+			localesAffected: 0,
+			message: "Nothing was written.",
+			warning: `"${targetKey}" already exists in "${toLayer}" with a different value in ${conflicts.length} locale(s). Resolve those locales first — reconcile the values, or move to a key that does not collide.`
+		}
+	};
+	if (opts.dryRun ?? false) return {
+		dryRun: true,
+		wouldMove: plan,
+		...identity,
+		summary: {
+			localesAffected: plan.length,
+			message: "Call again with dryRun: false to apply these changes."
+		}
+	};
+	const applied = await applyMove(config, {
+		fromLayer,
+		toLayer,
+		key,
+		targetKey
+	}, plan);
+	return {
+		movedLocales: applied.moved,
+		...applied.deduplicated.length > 0 ? { deduplicatedLocales: applied.deduplicated } : {},
+		filesWritten: applied.filesWritten,
+		...identity
+	};
+}
+/**
+* Decide every locale's outcome before any of them is written, so that one
+* conflicting locale can stop the whole move rather than half of it.
+*/
+async function planMove(config, { fromLayer, toLayer, key, targetKey }) {
+	const plan = [];
+	const notFound = [];
+	const conflicts = [];
+	for (const locale of config.locales) {
+		const source = await readLocaleDataIfPresent(config, fromLayer, locale);
+		const value = source ? getNestedValue(source, key) : void 0;
+		if (value === void 0) {
+			notFound.push(locale.code);
+			continue;
+		}
+		const target = await readLocaleDataIfPresent(config, toLayer, locale);
+		const existing = target ? getNestedValue(target, targetKey) : void 0;
+		if (existing === void 0) plan.push({
+			locale: locale.code,
+			value,
+			action: "move"
+		});
+		else if (sameTranslation(existing, value)) plan.push({
+			locale: locale.code,
+			value,
+			action: "deduplicate"
+		});
+		else conflicts.push(locale.code);
+	}
+	return {
+		plan,
+		notFound,
+		conflicts
+	};
+}
+/** Execute an already-validated plan. */
+async function applyMove(config, { fromLayer, toLayer, key, targetKey }, plan) {
+	const moved = [];
+	const deduplicated = [];
+	const filesWritten = /* @__PURE__ */ new Set();
+	for (const entry of plan) {
+		const locale = findLocaleImpl(config, entry.locale);
+		if (!locale) continue;
+		if (entry.action === "move") {
+			for (const file of await mutateLocaleData(config, toLayer, locale, (data) => {
+				setNestedValue(data, targetKey, entry.value);
+			})) filesWritten.add(file);
+			moved.push(entry.locale);
+		} else deduplicated.push(entry.locale);
+		for (const file of await mutateLocaleData(config, fromLayer, locale, (data) => {
+			removeNestedValue(data, key);
+		})) filesWritten.add(file);
+	}
+	return {
+		moved,
+		deduplicated,
+		filesWritten: filesWritten.size
+	};
+}
+/**
+* Whether the target already holds what the move would write. Values are
+* usually strings, but a key can name a whole namespace object, so this
+* compares structurally rather than by identity.
+*/
+function sameTranslation(a, b) {
+	if (a === b) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	return JSON.stringify(a) === JSON.stringify(b);
+}
 //#endregion
 //#region src/core/ops-init.ts
 /**
@@ -5545,6 +6521,7 @@ function referenceLocaleAnchorPaths(config, layers, locale, projectDir) {
 * referenced in source code, plus code-usage scanning.
 */
 const MISPLACED_USAGE_NOTE = "Keys referenced only from apps that do not consume their layer. Either the key belongs in a broader (shared) layer, or the usage is a bug. These keys are not counted as orphans and are never removed.";
+const CANDIDATE_ONLY_NOTE = "These keys are protected only by the bare-candidate net: either a dotted string somewhere merely shares their name (often a comment or a data structure), or a call too ambiguous to commit to references them (a bare t(...) that could be anything). They are not offered for removal, but dead references hide here - verify before pruning.";
 /** True when `child` equals `parent` or lies inside it. */
 function isWithin(child, parent) {
 	const rel = relative(parent, child);
@@ -5763,17 +6740,21 @@ async function findOrphanKeys(opts) {
 	const output = {
 		orphanKeys: sortedByLayer,
 		uncertainKeys: orphanResult.uncertainCount > 0 ? orphanResult.uncertainByLayer : void 0,
+		candidateOnlyKeys: orphanResult.candidateOnlyCount > 0 ? orphanResult.candidateOnlyByLayer : void 0,
+		candidateOnlyNote: orphanResult.candidateOnlyCount > 0 ? CANDIDATE_ONLY_NOTE : void 0,
 		misplacedUsages: misplacedCount > 0 ? orphanResult.misplacedUsages : void 0,
 		misplacedUsageNote: misplacedCount > 0 ? MISPLACED_USAGE_NOTE : void 0,
 		summary: {
 			totalKeys,
 			orphanCount: orphanResult.orphanCount,
 			uncertainCount: orphanResult.uncertainCount,
+			candidateOnlyCount: orphanResult.candidateOnlyCount,
 			misplacedCount,
 			dynamicMatchedCount: orphanResult.dynamicMatchedCount,
 			ignoredCount: orphanResult.ignoredCount,
 			usedCount: totalKeys - orphanResult.orphanCount - orphanResult.uncertainCount - misplacedCount,
 			filesScanned: orphanResult.totalFilesScanned,
+			filesDeclined: orphanResult.totalFilesDeclined,
 			layersChecked: layersToCheck.map((d) => d.layer),
 			dirsScanned: orphanResult.dirsScanned,
 			scanScope: relativeScanScope(orphanResult, dir),
@@ -5818,9 +6799,11 @@ async function scanCodeUsage(opts) {
 	const allUsages = [];
 	const allDynamicKeys = [];
 	let totalFilesScanned = 0;
+	let totalFilesDeclined = 0;
 	for (const scanDir of dirsToScan) {
 		const result = await scanSourceFiles(scanDir, excludeDirs, getPatternSet(config.localeFileFormat));
 		totalFilesScanned += result.filesScanned;
+		totalFilesDeclined += result.declinedFiles.length;
 		allUsages.push(...result.usages);
 		allDynamicKeys.push(...result.dynamicKeys);
 	}
@@ -5840,6 +6823,7 @@ async function scanCodeUsage(opts) {
 			uniqueKeysFound: Object.keys(sortedByKey).length,
 			totalReferences: filteredUsages.length,
 			filesScanned: totalFilesScanned,
+			filesDeclined: totalFilesDeclined,
 			dirsScanned: dirsToScan
 		}
 	};
@@ -6084,6 +7068,26 @@ async function removeOrphanKeys(opts) {
 * Cross-layer duplicate-key detection: keys defined in both a shared layer
 * and a consuming child layer, compared in one reference locale.
 */
+/**
+* Values shorter than this are excluded from value grouping. "Ja", "OK" and
+* "Nein" repeat across unrelated namespaces legitimately, and reporting them
+* buries the findings worth acting on. A length floor is a blunt rule, which
+* is the point — anything cleverer would be guessing at intent.
+*/
+const DEFAULT_MIN_VALUE_LENGTH = 4;
+/**
+* A floor arrives as a CLI string or an MCP number, so it can be NaN or
+* negative by the time it lands here. Comparing a length against NaN is always
+* false, which silently removes the floor and buries the report in "OK" — the
+* opposite of what asking for a floor means. Saying so beats defaulting: the
+* caller asked for a specific threshold and would not learn it was ignored.
+*/
+function resolveMinValueLength(requested) {
+	if (requested === void 0) return DEFAULT_MIN_VALUE_LENGTH;
+	if (!Number.isFinite(requested) || requested < 0) throw new ToolError(`minValueLength must be a non-negative number, got ${String(requested)}.`, "INVALID_MIN_VALUE_LENGTH");
+	return Math.floor(requested);
+}
+const VALUE_DUPLICATE_GUIDANCE = "Different keys carrying the same value. \"reuse\" means a shared layer already defines this value: delete the app-layer keys and repoint their call sites at the shared key. \"promote\" means two or more app layers define it and no shared layer does: move one to a shared layer (move_translation_key) and repoint the rest. \"consolidate\" is duplication inside one layer. Each duplicate is translated into every locale separately, so removing one saves provider spend on every future translate run, not just tidiness. Short generic labels (\"Name\", \"Status\") dominate the list by group size and are the least worth acting on individually; raise minValueLength to see the longer copy, where duplication is rarely deliberate.";
 const DUPLICATE_GUIDANCE = "At runtime the child layer's value shadows the shared layer's value for the same key. Fix each collision by deleting one side — usually the shared copy when the child value is authoritative, or the child copy to fall through to the shared value. Never move the key: both layers already define it.";
 /** Leaf values may be arrays (getLeafKeys treats them as leaves) — compare
 *  those structurally; identity covers primitives. */
@@ -6137,25 +7141,75 @@ function emptyPairsMessage(config) {
 	return "No (shared layer, child layer) pairs to check — no app consumes more than one locale-backed layer.";
 }
 /**
-* Find keys defined in both a shared layer and a consuming child layer,
-* comparing values in a single reference locale (default: the project
-* default locale). Pure locale-file I/O — no source scanning.
+* Group keys by the value they carry, so that two keys spelling the same
+* string differently are visible as the duplication they are.
+*
+* Key-path collision detection cannot see this: `common.actions.save` and
+* `calendar.views.save` collide on nothing while both holding "Speichern"
+* (#343). Each duplicate is then translated into every locale independently,
+* so the duplication costs provider spend on every run, not just tidiness.
 */
-async function findDuplicateKeys(opts = {}) {
-	const dir = opts.projectDir ?? process.cwd();
-	const config = await detectI18nConfig(dir);
-	const locale = opts.locale ? findLocaleOrThrow(config, opts.locale) : findLocaleImpl(config, config.defaultLocale) ?? config.locales[0];
-	if (!locale) throw new ToolError("No locales found in configuration.", "LOCALE_NOT_FOUND");
-	const pairs = deriveLayerPairs(config, buildLayerGraph(config));
-	const layerDataCache = /* @__PURE__ */ new Map();
-	const dataFor = (layer) => {
-		let cached = layerDataCache.get(layer);
-		if (!cached) {
-			cached = readLocaleData(config, layer, locale);
-			layerDataCache.set(layer, cached);
-		}
-		return cached;
+function groupByValue(entries, sharedLayers, minValueLength) {
+	const byNormalized = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (typeof entry.value !== "string") continue;
+		const normalized = normalizeValue(entry.value);
+		if (normalized.length < minValueLength) continue;
+		const group = byNormalized.get(normalized) ?? {
+			value: entry.value,
+			normalized,
+			action: "consolidate",
+			members: []
+		};
+		group.members.push({
+			key: entry.key,
+			layer: entry.layer,
+			shared: sharedLayers.has(entry.layer)
+		});
+		byNormalized.set(normalized, group);
+	}
+	const groups = [...byNormalized.values()].filter((group) => group.members.length > 1 && new Set(group.members.map((m) => m.key)).size > 1);
+	for (const group of groups) group.action = classifyGroup(group.members);
+	const rank = {
+		reuse: 0,
+		promote: 1,
+		consolidate: 2
 	};
+	return groups.sort((a, b) => rank[a.action] - rank[b.action] || b.members.length - a.members.length || a.normalized.localeCompare(b.normalized));
+}
+function classifyGroup(members) {
+	const inShared = members.filter((m) => m.shared);
+	if (inShared.length > 0 && inShared.length < members.length) return "reuse";
+	if (new Set(members.map((m) => m.layer)).size > 1) return "promote";
+	return "consolidate";
+}
+/**
+* Fold away the differences that do not change what a translator would write:
+* surrounding space, capitalisation, internal whitespace runs and trailing
+* punctuation. "Speichern", "speichern " and "Speichern." group together.
+*/
+function normalizeValue(value) {
+	return value.trim().replace(/\s+/g, " ").replace(/[.!?:;,\u2026]+$/u, "").toLowerCase();
+}
+/** Every leaf key of every canonical layer, minus the ones config says to ignore. */
+async function collectLayerEntries(config, layers, dataFor) {
+	const entries = [];
+	for (const layer of layers) {
+		const data = await dataFor(layer.layer);
+		const ignore = buildIgnorePatternRegexes(resolveOrphanIgnorePatterns(config, layer.layer) ?? []);
+		for (const key of getLeafKeys(data)) {
+			if (ignore.some((re) => re.test(key))) continue;
+			entries.push({
+				key,
+				layer: layer.layer,
+				value: getNestedValue(data, key)
+			});
+		}
+	}
+	return entries;
+}
+/** Keys defined on both sides of each (shared, child) pair, in one locale. */
+async function findCollisions(pairs, dataFor) {
 	const collisions = [];
 	for (const { shared, child } of pairs) {
 		const sharedData = await dataFor(shared.layer);
@@ -6175,23 +7229,57 @@ async function findDuplicateKeys(opts = {}) {
 			});
 		}
 	}
+	return collisions;
+}
+/**
+* Find keys defined in both a shared layer and a consuming child layer,
+* comparing values in a single reference locale (default: the project
+* default locale). Pure locale-file I/O — no source scanning.
+*/
+async function findDuplicateKeys(opts = {}) {
+	const dir = opts.projectDir ?? process.cwd();
+	const config = await detectI18nConfig(dir);
+	const locale = opts.locale ? findLocaleOrThrow(config, opts.locale) : findLocaleImpl(config, config.defaultLocale) ?? config.locales[0];
+	if (!locale) throw new ToolError("No locales found in configuration.", "LOCALE_NOT_FOUND");
+	const graph = buildLayerGraph(config);
+	const pairs = deriveLayerPairs(config, graph);
+	const layerDataCache = /* @__PURE__ */ new Map();
+	const dataFor = (layer) => {
+		let cached = layerDataCache.get(layer);
+		if (!cached) {
+			cached = readLocaleData(config, layer, locale);
+			layerDataCache.set(layer, cached);
+		}
+		return cached;
+	};
+	const collisions = await findCollisions(pairs, dataFor);
+	const valueDuplicates = opts.byValue ? groupByValue(await collectLayerEntries(config, graph.canonicalLayers, dataFor), new Set(pairs.map((pair) => pair.shared.layer)), resolveMinValueLength(opts.minValueLength)) : void 0;
 	const summary = {
 		totalCollisions: collisions.length,
 		divergentCount: collisions.filter((c) => c.divergent).length,
 		pairsChecked: pairs.length,
 		locale: locale.code,
+		...valueDuplicates ? {
+			valueGroups: valueDuplicates.length,
+			reusableGroups: valueDuplicates.filter((g) => g.action === "reuse").length
+		} : {},
 		...pairs.length === 0 ? { message: emptyPairsMessage(config) } : {}
 	};
 	const output = {
 		collisions,
-		guidance: DUPLICATE_GUIDANCE,
+		...valueDuplicates ? { valueDuplicates } : {},
+		guidance: valueDuplicates ? `${DUPLICATE_GUIDANCE}\n\n${VALUE_DUPLICATE_GUIDANCE}` : DUPLICATE_GUIDANCE,
 		summary
 	};
 	const reportPath = resolveOutputFile(dir, opts.outputFile) ?? resolveReportFilePath(config, dir, "find_duplicate_keys");
 	if (reportPath) {
 		await writeReportFile(reportPath, output, {
 			tool: "find_duplicate_keys",
-			args: { locale: opts.locale }
+			args: {
+				locale: opts.locale,
+				byValue: opts.byValue,
+				minValueLength: opts.minValueLength
+			}
 		});
 		return {
 			reportFile: reportPath,
@@ -6400,11 +7488,13 @@ async function checkUndefinedKeys(opts = {}) {
 	const searchedLayersByApp = {};
 	const checkedKeys = /* @__PURE__ */ new Set();
 	let filesScanned = 0;
+	let filesDeclined = 0;
 	let ignoredCount = 0;
 	for (const unit of units) {
 		const ignores = globalScope ? [] : nestedUnitIgnores(unit, units);
 		const scan = await scanSourceFiles(unit.dir, [...opts.excludeDirs ?? [], ...ignores], patterns);
 		filesScanned += scan.filesScanned;
+		filesDeclined += scan.declinedFiles.length;
 		const searchedLayers = layersForUnit(unit.name);
 		searchedLayersByApp[unit.name] = searchedLayers;
 		const outcome = classifyUnitUsages(scan, {
@@ -6427,6 +7517,7 @@ async function checkUndefinedKeys(opts = {}) {
 		uncertainCount: uncertainKeys.length,
 		ignoredCount,
 		filesScanned,
+		filesDeclined,
 		locale: localeCode,
 		searchedLayersByApp,
 		message: buildCheckMessage(undefinedKeys.length, uncertainKeys.length)
@@ -6459,6 +7550,6 @@ async function checkUndefinedKeys(opts = {}) {
 	return output;
 }
 //#endregion
-export { translateMissing as C, detectI18nConfig as D, clearConfigCache as E, getCachedConfig as O, translateKey as S, buildLayerGraph as T, getTranslations as _, scanCodeUsage as a, searchTranslations as b, addTranslations as c, scaffoldLocaleFiles as d, updateTranslations as f, getMissingTranslations as g, findEmptyTranslations as h, removeOrphanKeys as i, findLocaleImpl as k, removeTranslations as l, detectConfig as m, findDuplicateKeys as n, getTranslationStatus as o, writeTranslations as p, findOrphanKeys as r, initProjectConfig as s, checkUndefinedKeys as t, renameTranslationKey as u, listLocaleDirs as v, readLocaleData as w, resolveProtectedLocales as x, listNamespaces as y };
+export { resolveProtectedLocales as A, detectConfig as C, listLocaleDirs as D, getTranslations as E, serializeLayerGraph as F, clearConfigCache as I, detectI18nConfig as L, translateMissing as M, readLocaleData as N, listNamespaces as O, buildLayerGraph as P, getCachedConfig as R, createOxcFrontend as S, getMissingTranslations as T, getPatternSet as _, scanCodeUsage as a, LARAVEL_PATTERNS as b, addTranslations as c, renameTranslationKey as d, scaffoldLocaleFiles as f, VUE_NUXT_PATTERNS as g, scanSourceFiles as h, removeOrphanKeys as i, translateKey as j, searchTranslations as k, moveTranslationKey as l, writeTranslations as m, findDuplicateKeys as n, getTranslationStatus as o, updateTranslations as p, findOrphanKeys as r, initProjectConfig as s, checkUndefinedKeys as t, removeTranslations as u, createPatternsFrontend as v, findEmptyTranslations as w, createPhpFrontend as x, createBladeFrontend as y, findLocaleImpl as z };
 
-//# sourceMappingURL=operations-BCJd7in3.js.map
+//# sourceMappingURL=operations-CTo44gPu.js.map