@x18n/core 0.0.2 → 0.0.5

package/dist/index.mjs

@@ -0,0 +1,3046 @@
+import * as v from "valibot";
+//#region src/text.ts
+/** One edit covering only the part that differs, so bytes outside it stay the same. */
+function diffText(before, after) {
+	if (before === after) return [];
+	let start = 0;
+	const max = Math.min(before.length, after.length);
+	while (start < max && before.charCodeAt(start) === after.charCodeAt(start)) start++;
+	let endBefore = before.length;
+	let endAfter = after.length;
+	while (endBefore > start && endAfter > start && before.charCodeAt(endBefore - 1) === after.charCodeAt(endAfter - 1)) {
+		endBefore--;
+		endAfter--;
+	}
+	return [{
+		range: {
+			start,
+			end: endBefore
+		},
+		text: after.slice(start, endAfter)
+	}];
+}
+/** Applies non-overlapping edits given against the same text. */
+function applyTextEdits(text, edits) {
+	const sorted = [...edits].sort((a, b) => b.range.start - a.range.start || b.range.end - a.range.end);
+	let out = text;
+	for (const edit of sorted) out = out.slice(0, edit.range.start) + edit.text + out.slice(edit.range.end);
+	return out;
+}
+const lineIndexes = /* @__PURE__ */ new Map();
+/** Line index of a text, cached for the few texts used at a time (reporters, LSP ranges). */
+function createLineIndex(text) {
+	let index = lineIndexes.get(text);
+	if (!index) {
+		if (lineIndexes.size >= 16) lineIndexes.delete(lineIndexes.keys().next().value);
+		index = buildLineIndex(text);
+		lineIndexes.set(text, index);
+	}
+	return index;
+}
+function buildLineIndex(text) {
+	const starts = [0];
+	for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1);
+	return {
+		lineCount: starts.length,
+		position(offset) {
+			let low = 0;
+			let high = starts.length - 1;
+			while (low < high) {
+				const mid = low + high + 1 >> 1;
+				if (starts[mid] <= offset) low = mid;
+				else high = mid - 1;
+			}
+			return {
+				line: low,
+				character: offset - starts[low]
+			};
+		},
+		offset(position) {
+			const start = starts[Math.min(position.line, starts.length - 1)] ?? 0;
+			return Math.min(start + position.character, text.length);
+		},
+		line(line) {
+			const start = starts[line] ?? text.length;
+			const end = starts[line + 1] ?? text.length;
+			return text.slice(start, end).replace(/\r?\n$/, "");
+		}
+	};
+}
+function rangeContains(range, offset) {
+	return offset >= range.start && offset <= range.end;
+}
+/** Fast non-cryptographic string hash (cyrb53), as hex. */
+function hashText(text) {
+	let h1 = 3735928559;
+	let h2 = 1103547991;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16);
+}
+//#endregion
+//#region src/contracts.ts
+/** Version of every JSON contract (CLI `--json`, LSP `x18n/*`, RPC, MCP). Bumped on breaking changes to any `data` shape. */
+const contractVersion = 1;
+/** Line and column form of an offset range in a text. */
+function toWireRange(text, start, end) {
+	const index = createLineIndex(text ?? "");
+	const from = index.position(start);
+	const to = index.position(end);
+	return {
+		line: from.line + 1,
+		column: from.character + 1,
+		endLine: to.line + 1,
+		endColumn: to.character + 1,
+		start,
+		end
+	};
+}
+function toWireDiagnostic(project, diagnostic, text) {
+	const location = diagnostic.location;
+	return {
+		project,
+		code: diagnostic.code,
+		severity: diagnostic.severity,
+		message: diagnostic.message,
+		key: diagnostic.key,
+		locale: diagnostic.locale,
+		file: location?.path,
+		range: location ? toWireRange(text(location.path), location.range.start, location.range.end) : void 0,
+		fixes: diagnostic.fixes
+	};
+}
+function envelope(command, data, diagnostics = [], errors = []) {
+	return {
+		x18n: 1,
+		command,
+		data,
+		diagnostics,
+		errors
+	};
+}
+//#endregion
+//#region src/define.ts
+function definePlugin(plugin) {
+	return plugin;
+}
+function definePreset(preset) {
+	return preset;
+}
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+//#region src/errors.ts
+const errorCodes = {
+	X18N0001: {
+		message: "Invalid config",
+		hint: "Check the reported field against the config schema (`x18n schema config`)."
+	},
+	X18N0002: {
+		message: "Config file could not be loaded",
+		hint: "Fix the syntax error, or run `x18n doctor` for details."
+	},
+	X18N0003: {
+		message: "Unknown project",
+		hint: "Pick a project name listed by `x18n status`."
+	},
+	X18N1001: {
+		message: "Plugin could not be loaded",
+		hint: "Install the plugin package, or check the path."
+	},
+	X18N1002: {
+		message: "Duplicate capability id",
+		hint: "Rename the id, or set `override: true` on the later one."
+	},
+	X18N1003: {
+		message: "Unknown preset",
+		hint: "Use a preset name listed in the docs, or a preset object."
+	},
+	X18N1004: {
+		message: "Invalid YAML plugin",
+		hint: "Validate the file against `schema/plugin.json`."
+	},
+	X18N2001: {
+		message: "No format for resource",
+		hint: "Map the extension in `formats`, or add a format plugin."
+	},
+	X18N2002: {
+		message: "Resource could not be parsed",
+		hint: "Fix the syntax error in the file."
+	},
+	X18N2003: {
+		message: "Resource is not an object of messages",
+		hint: "Locale files hold nested objects of strings, numbers, booleans or null."
+	},
+	X18N2004: {
+		message: "Locale file is not static",
+		hint: "Use JSON or YAML, or opt in to execution with `execute: true` on the resource pattern."
+	},
+	X18N3001: {
+		message: "Source file could not be scanned",
+		hint: "Fix the syntax error, or exclude the file with `usage.exclude`."
+	},
+	X18N4001: {
+		message: "Resource is read-only",
+		hint: "Edit the source of computed values, or use a writable format."
+	},
+	X18N4002: {
+		message: "Rename target already exists",
+		hint: "Delete or rename the existing key first."
+	},
+	X18N4003: {
+		message: "A decision is needed",
+		hint: "Answer the listed decisions, or pass `--yes` to accept defaults."
+	},
+	X18N4004: {
+		message: "Plan is stale",
+		hint: "Files changed since the plan was made. Plan again."
+	},
+	X18N4005: {
+		message: "No resource for the key",
+		hint: "Add a resource pattern for the locale, or create the locale file."
+	},
+	X18N4006: {
+		message: "Key not found",
+		hint: "List keys with `x18n keys`."
+	},
+	X18N4007: {
+		message: "Placeholder mismatch",
+		hint: "Keep every placeholder of the source value, or pass `--force`."
+	},
+	X18N4008: {
+		message: "Invalid edit input",
+		hint: "Check the input shape against the docs."
+	}
+};
+var X18nError = class extends Error {
+	code;
+	hint;
+	docs;
+	details;
+	constructor(code, detail, details = []) {
+		const base = errorCodes[code];
+		super(detail ? `${base.message}: ${detail}` : base.message);
+		this.name = "X18nError";
+		this.code = code;
+		this.hint = base.hint;
+		this.docs = `https://x18n.antfu.dev/errors/${code.toLowerCase()}`;
+		this.details = details;
+	}
+	toJSON() {
+		return {
+			code: this.code,
+			message: this.message,
+			hint: this.hint,
+			docs: this.docs
+		};
+	}
+};
+function isX18nError(error) {
+	return error instanceof X18nError;
+}
+//#endregion
+//#region src/keys.ts
+/** Canonical string form of a key: `ns:a.b.c`, or `a.b.c` without namespace. */
+function joinKey(namespace, path) {
+	const dotted = path.join(".");
+	return namespace === void 0 ? dotted : `${namespace}:${dotted}`;
+}
+/** Splits a key string. `namespaced` is false for projects without namespaces, where `:` is part of the key. */
+function splitKey(key, namespaced = true) {
+	const index = namespaced ? key.indexOf(":") : -1;
+	const namespace = index === -1 ? void 0 : key.slice(0, index);
+	const rest = index === -1 ? key : key.slice(index + 1);
+	return {
+		namespace,
+		path: rest === "" ? [] : rest.split(".")
+	};
+}
+/** True when `key` is `prefix` itself or lies under it (`a.b` is under `a`). */
+function isKeyUnder(key, prefix) {
+	if (key === prefix) return true;
+	const sep = prefix.endsWith(":") ? "" : ".";
+	return key.startsWith(prefix + sep);
+}
+/** Replaces the `from` prefix of `key` with `to`. */
+function replaceKeyPrefix(key, from, to) {
+	return key === from ? to : to + key.slice(from.length);
+}
+function escapeRegExp(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Glob over paths. `**` spans separators, `*` and `?` stay inside a segment,
+* `{a,b}` alternates, `[...]` is a character class.
+*/
+function globToRegExp(glob, separator = "/") {
+	const sep = escapeRegExp(separator);
+	const notSep = `[^${sep}]`;
+	let out = "";
+	let depth = 0;
+	for (let i = 0; i < glob.length; i++) {
+		const char = glob[i];
+		if (char === "*") {
+			if (glob[i + 1] === "*") {
+				const slashAfter = glob[i + 2] === separator;
+				const atStart = i === 0 || glob[i - 1] === separator;
+				i++;
+				if (slashAfter && atStart) {
+					out += `(?:.*${sep})?`;
+					i++;
+				} else out += ".*";
+			} else out += `${notSep}*`;
+		} else if (char === "?") out += notSep;
+		else if (char === "{") {
+			depth++;
+			out += "(?:";
+		} else if (char === "}" && depth > 0) {
+			depth--;
+			out += ")";
+		} else if (char === "," && depth > 0) out += "|";
+		else if (char === "[") {
+			const close = glob.indexOf("]", i);
+			if (close === -1) out += "\\[";
+			else {
+				out += `[${glob.slice(i + 1, close).replace(/^!/, "^").replace(/\\/g, "\\\\")}]`;
+				i = close;
+			}
+		} else out += escapeRegExp(char);
+	}
+	return new RegExp(`^${out}$`);
+}
+/** Matcher over key globs: `*` stays inside a segment, `**` spans segments. */
+function keyMatcher(globs) {
+	if (globs.length === 0) return () => false;
+	const regexes = globs.map((glob) => globToRegExp(glob, "."));
+	return (key) => regexes.some((re) => re.test(key));
+}
+/** Matcher over posix file paths. */
+function pathMatcher(globs) {
+	if (globs.length === 0) return () => false;
+	const regexes = globs.map((glob) => globToRegExp(glob.replace(/^\.\//, "")));
+	return (path) => regexes.some((re) => re.test(path));
+}
+//#endregion
+//#region src/locale.ts
+const defaultRegions = {
+	ar: "SA",
+	cs: "CZ",
+	da: "DK",
+	de: "DE",
+	el: "GR",
+	en: "US",
+	es: "ES",
+	fa: "IR",
+	fi: "FI",
+	fr: "FR",
+	he: "IL",
+	hi: "IN",
+	hu: "HU",
+	id: "ID",
+	it: "IT",
+	ja: "JP",
+	ko: "KR",
+	nb: "NO",
+	nl: "NL",
+	pl: "PL",
+	pt: "PT",
+	ro: "RO",
+	ru: "RU",
+	sv: "SE",
+	th: "TH",
+	tr: "TR",
+	uk: "UA",
+	vi: "VN",
+	zh: "CN"
+};
+const pluralOrder = [
+	"zero",
+	"one",
+	"two",
+	"few",
+	"many",
+	"other"
+];
+function flagOf(region) {
+	if (!/^[A-Z]{2}$/.test(region)) return void 0;
+	return String.fromCodePoint(...[...region].map((c) => 127462 + c.charCodeAt(0) - 65));
+}
+function safe(fn) {
+	try {
+		return fn();
+	} catch {
+		return;
+	}
+}
+/** Lenient display parse of a locale code (`zh_CN`, `pt-BR`, `sr-Latn-RS`). Never changes the code. */
+function parseLocaleInfo(code) {
+	const parts = code.replace(/_/g, "-").split("-").filter(Boolean);
+	const language = parts[0] && /^[a-z]{2,3}$/i.test(parts[0]) ? parts[0].toLowerCase() : void 0;
+	let script;
+	let region;
+	for (const part of parts.slice(1)) if (!script && !region && /^[a-z]{4}$/i.test(part)) script = part[0].toUpperCase() + part.slice(1).toLowerCase();
+	else if (!region && /^(?:[a-z]{2}|\d{3})$/i.test(part)) region = part.toUpperCase();
+	const tag = [
+		language,
+		script,
+		region
+	].filter(Boolean).join("-");
+	const displayName = language ? safe(() => new Intl.DisplayNames(["en"], { type: "language" }).of(tag)) : void 0;
+	const found = language ? safe(() => new Intl.PluralRules(tag).resolvedOptions().pluralCategories) : void 0;
+	const pluralCategories = found ? pluralOrder.filter((category) => found.includes(category)) : ["other"];
+	const flagRegion = region ?? (language === "zh" && script === "Hant" ? "TW" : language ? defaultRegions[language] : void 0);
+	return {
+		code,
+		language,
+		region,
+		displayName,
+		flag: flagRegion ? flagOf(flagRegion) : void 0,
+		pluralCategories
+	};
+}
+/** Codes that differ only in spelling (`zh_CN` and `zh-cn`), the same after a lenient normalization. */
+function localeSpellingKey(code) {
+	return code.replace(/_/g, "-").toLowerCase();
+}
+//#endregion
+//#region src/memory-host.ts
+/** A host over in-memory files, for tests, demos and agents that pass content directly. */
+function createMemoryHost(initial = {}, root = "/") {
+	const files = new Map(Object.entries(initial));
+	return {
+		root,
+		files,
+		readFile: async (path) => files.get(path),
+		writeFile: async (path, content) => {
+			files.set(path, content);
+		},
+		deleteFile: async (path) => {
+			files.delete(path);
+		},
+		glob: async (patterns, options = {}) => {
+			const include = pathMatcher(patterns);
+			const ignore = pathMatcher(options.ignore ?? []);
+			return [...files.keys()].filter((path) => include(path) && !ignore(path)).sort();
+		}
+	};
+}
+//#endregion
+//#region src/message-tree.ts
+function isMessageLeaf(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+/** Checks parsed data (for example from `JSON.parse`) before it enters the project. */
+function isMessageTree(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	return Object.values(value).every((child) => isMessageLeaf(child) || isMessageTree(child));
+}
+/** Stable id of a stored property path, the key of `ParseResult.ranges`. */
+function pathId(path) {
+	return path.join("\0");
+}
+function* walkLeaves(tree, prefix = []) {
+	for (const [segment, child] of Object.entries(tree)) {
+		const path = [...prefix, segment];
+		if (isMessageLeaf(child)) yield {
+			path,
+			value: child
+		};
+		else yield* walkLeaves(child, path);
+	}
+}
+function cloneTree(tree) {
+	const out = {};
+	for (const [segment, child] of Object.entries(tree)) out[segment] = isMessageLeaf(child) ? child : cloneTree(child);
+	return out;
+}
+function setIn(tree, path, value) {
+	let node = tree;
+	for (const segment of path.slice(0, -1)) {
+		const child = node[segment];
+		if (child === void 0 || isMessageLeaf(child)) {
+			const created = {};
+			node[segment] = created;
+			node = created;
+		} else node = child;
+	}
+	node[path.at(-1)] = value;
+}
+function deleteIn(tree, path) {
+	const parents = [tree];
+	let node = tree;
+	for (const segment of path.slice(0, -1)) {
+		const child = node[segment];
+		if (child === void 0 || isMessageLeaf(child)) return;
+		node = child;
+		parents.push(node);
+	}
+	delete node[path.at(-1)];
+	for (let i = parents.length - 1; i > 0; i--) {
+		if (Object.keys(parents[i]).length > 0) break;
+		delete parents[i - 1][path[i - 1]];
+	}
+}
+/** Applies ops to a copy of the tree. Parent objects left empty are removed. */
+function applyMessageOps(tree, ops) {
+	const out = cloneTree(tree);
+	for (const op of ops) if (op.type === "set") setIn(out, op.path, op.value);
+	else deleteIn(out, op.path);
+	return out;
+}
+/** Sorts keys at every level. */
+function sortTree(tree, compare) {
+	const out = {};
+	for (const segment of Object.keys(tree).sort(compare)) {
+		const child = tree[segment];
+		out[segment] = isMessageLeaf(child) ? child : sortTree(child, compare);
+	}
+	return out;
+}
+/** Builds a nested or flat tree from leaves. */
+function buildTree(leaves) {
+	const out = {};
+	for (const leaf of leaves) setIn(out, leaf.path, leaf.value);
+	return out;
+}
+//#endregion
+//#region src/overlay-host.ts
+/** Wraps a host so open editor buffers shadow the content on disk. */
+function createOverlayHost(base) {
+	const overlays = /* @__PURE__ */ new Map();
+	return {
+		...base,
+		readFile: async (path) => overlays.get(path) ?? base.readFile(path),
+		async writeFile(path, content) {
+			overlays.delete(path);
+			await base.writeFile(path, content);
+		},
+		setOverlay: (path, content) => {
+			overlays.set(path, content);
+		},
+		clearOverlay: (path) => {
+			overlays.delete(path);
+		},
+		hasOverlay: (path) => overlays.has(path)
+	};
+}
+//#endregion
+//#region src/plugins.ts
+function isPreset(value) {
+	return "plugins" in value && Array.isArray(value.plugins);
+}
+function extensionOf(path) {
+	const base = path.slice(path.lastIndexOf("/") + 1);
+	const dot = base.lastIndexOf(".");
+	return dot <= 0 ? "" : base.slice(dot + 1).toLowerCase();
+}
+function sortByEnforce(plugins) {
+	const rank = (plugin) => plugin.enforce === "pre" ? 0 : plugin.enforce === "post" ? 2 : 1;
+	return [...plugins].sort((a, b) => rank(a) - rank(b));
+}
+function uniqueById(items, kind) {
+	const out = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		if (out.has(item.id) && !item.override) throw new X18nError("X18N1002", `${kind} "${item.id}"`);
+		out.set(item.id, item);
+	}
+	return out;
+}
+function createRegistry(input, config) {
+	const plugins = sortByEnforce(input);
+	const formats = plugins.flatMap((plugin) => plugin.formats ?? []);
+	const scanners = plugins.flatMap((plugin) => plugin.scanners ?? []);
+	const finders = [...uniqueById(plugins.flatMap((plugin) => plugin.localeFinders ?? []), "Locale finder").values()];
+	const checks = uniqueById(plugins.flatMap((plugin) => plugin.checks ?? []), "Check");
+	const reporters = uniqueById(plugins.flatMap((plugin) => plugin.reporters ?? []), "Reporter");
+	const conflicts = [];
+	const byExtension = /* @__PURE__ */ new Map();
+	for (const format of formats) for (const extension of format.extensions) {
+		const winner = byExtension.get(extension);
+		if (winner) conflicts.push({
+			capability: "format",
+			extension,
+			winner: winner.id,
+			loser: format.id
+		});
+		else byExtension.set(extension, format);
+	}
+	const formatById = (id) => formats.find((format) => format.id === id);
+	const scannerCache = /* @__PURE__ */ new Map();
+	return {
+		plugins,
+		formats,
+		finders,
+		scanners,
+		checks,
+		reporters,
+		placeholders: plugins.flatMap((plugin) => plugin.placeholders ?? []),
+		manifests: plugins.flatMap((plugin) => plugin.manifests ?? []),
+		extractors: plugins.flatMap((plugin) => plugin.extractors ?? []),
+		histories: plugins.flatMap((plugin) => plugin.histories ?? []),
+		conflicts,
+		formatById,
+		formatFor(path, hint) {
+			if (hint) return formatById(hint);
+			const extension = extensionOf(path);
+			const mapped = config.formats[extension];
+			return mapped ? formatById(mapped) : byExtension.get(extension);
+		},
+		scannersFor(path) {
+			const extension = extensionOf(path);
+			let list = scannerCache.get(extension);
+			if (!list) {
+				list = extension ? scanners.filter((scanner) => scanner.extensions.includes(extension) || scanner.extensions.includes("*")) : [];
+				scannerCache.set(extension, list);
+			}
+			return list;
+		}
+	};
+}
+//#endregion
+//#region src/schema.ts
+function isJsonValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return true;
+	if (Array.isArray(value)) return value.every(isJsonValue);
+	return isJsonObject(value);
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every(isJsonValue);
+}
+const jsonObject = v.custom(isJsonObject, "Expected a JSON object");
+const strings = v.array(v.string());
+const level = v.picklist([
+	"error",
+	"warning",
+	"info",
+	"hint",
+	"off"
+]);
+const argSource = v.strictObject({
+	arg: v.number(),
+	property: v.optional(v.string())
+});
+const callSpec = v.strictObject({
+	callee: v.union([v.string(), strings]),
+	kind: v.optional(v.picklist([
+		"call",
+		"selector",
+		"accessor"
+	])),
+	key: v.optional(v.union([v.number(), argSource])),
+	namespace: v.optional(argSource),
+	keyPrefix: v.optional(argSource),
+	factory: v.optional(v.boolean()),
+	returns: v.optional(strings),
+	types: v.optional(strings)
+});
+const regexSpec = v.strictObject({
+	extensions: strings,
+	patterns: strings
+});
+const resourceSpec = v.strictObject({
+	pattern: v.string(),
+	format: v.optional(v.string()),
+	namespace: v.optional(v.string()),
+	locale: v.optional(v.string()),
+	execute: v.optional(v.boolean())
+});
+const pluginSpecifier = v.union([v.string(), v.tuple([v.string(), jsonObject])]);
+const extractTemplate = v.strictObject({
+	template: v.string(),
+	kinds: v.optional(strings),
+	files: v.optional(strings),
+	imports: v.optional(strings)
+});
+const extractTemplates = v.array(v.union([v.string(), extractTemplate]));
+const extractOptions = v.strictObject({
+	autoDetect: v.optional(v.boolean()),
+	keygen: v.optional(v.picklist([
+		"slug",
+		"source",
+		"random",
+		"empty"
+	])),
+	keyCase: v.optional(v.picklist([
+		"camel",
+		"snake",
+		"kebab",
+		"dot"
+	])),
+	keyPrefix: v.optional(v.string()),
+	keyMaxLength: v.optional(v.number()),
+	reuseExisting: v.optional(v.boolean()),
+	ignore: v.optional(strings),
+	ignoreByFile: v.optional(v.record(v.string(), strings)),
+	ignoreAttributes: v.optional(strings),
+	ignoreCallees: v.optional(strings),
+	templates: v.optional(extractTemplates)
+});
+const glossaryEntry = v.strictObject({
+	term: v.string(),
+	translations: v.optional(v.record(v.string(), v.string())),
+	note: v.optional(v.string()),
+	doNotTranslate: v.optional(v.boolean())
+});
+const checkSetting = v.union([level, v.tuple([level, jsonObject])]);
+const namespaceOptions = v.strictObject({
+	separator: v.optional(v.string()),
+	default: v.optional(v.string()),
+	fromPath: v.optional(v.picklist([
+		"dot",
+		"slash",
+		"camel"
+	]))
+});
+/** Validates YAML and JSON configs, and the serializable part of TS configs. */
+const ConfigSchema = v.strictObject({
+	$schema: v.optional(v.string()),
+	root: v.optional(v.string()),
+	name: v.optional(v.string()),
+	sourceLocale: v.optional(v.string()),
+	locales: v.optional(strings),
+	ignoreLocales: v.optional(strings),
+	presets: v.optional(v.union([v.literal("auto"), v.array(pluginSpecifier)])),
+	plugins: v.optional(v.array(pluginSpecifier)),
+	resources: v.optional(v.array(resourceSpec)),
+	formats: v.optional(v.record(v.string(), v.string())),
+	keyStyle: v.optional(v.picklist([
+		"auto",
+		"nested",
+		"flat"
+	])),
+	namespace: v.optional(namespaceOptions),
+	usage: v.optional(v.strictObject({
+		include: v.optional(strings),
+		exclude: v.optional(strings),
+		calls: v.optional(v.array(callSpec)),
+		regex: v.optional(v.array(regexSpec)),
+		ignoreCallees: v.optional(strings),
+		keysInUse: v.optional(strings),
+		derivedKeys: v.optional(strings)
+	})),
+	write: v.optional(v.strictObject({
+		sort: v.optional(v.union([v.literal(false), v.picklist(["binary", "locale"])])),
+		indent: v.optional(v.union([v.number(), v.literal("tab")])),
+		keepFilled: v.optional(v.boolean())
+	})),
+	extract: v.optional(extractOptions),
+	checks: v.optional(v.record(v.string(), checkSetting)),
+	strict: v.optional(v.boolean()),
+	ignoreKeys: v.optional(strings),
+	glossary: v.optional(v.array(glossaryEntry)),
+	history: v.optional(v.union([v.boolean(), v.record(v.string(), v.union([v.literal(false), v.looseObject({})]))])),
+	projects: v.optional(strings)
+});
+const PluginFileSchema = v.strictObject({
+	$schema: v.optional(v.string()),
+	name: v.string(),
+	detect: v.optional(v.strictObject({
+		dependencies: v.optional(v.strictObject({
+			any: v.optional(strings),
+			all: v.optional(strings)
+		})),
+		files: v.optional(strings)
+	})),
+	exclusive: v.optional(v.boolean()),
+	config: v.optional(v.strictObject({
+		sourceLocale: v.optional(v.string()),
+		locales: v.optional(strings),
+		resources: v.optional(v.array(resourceSpec)),
+		namespace: v.optional(namespaceOptions),
+		keyStyle: v.optional(v.picklist([
+			"auto",
+			"nested",
+			"flat"
+		]))
+	})),
+	scanners: v.optional(v.strictObject({
+		calls: v.optional(v.array(callSpec)),
+		regex: v.optional(v.array(regexSpec))
+	})),
+	scopes: v.optional(v.strictObject({ regex: v.string() })),
+	derivedKeys: v.optional(strings),
+	normalizeKey: v.optional(v.array(v.strictObject({ replace: v.strictObject({
+		pattern: v.string(),
+		with: v.string()
+	}) }))),
+	placeholders: v.optional(strings),
+	localeInfo: v.optional(v.record(v.string(), v.strictObject({
+		flag: v.optional(v.string()),
+		displayName: v.optional(v.string())
+	}))),
+	extract: v.optional(v.strictObject({ templates: v.optional(extractTemplates) }))
+});
+/** Validates data against a schema and returns readable issues instead of throwing. */
+function validate(schema, data) {
+	const result = v.safeParse(schema, data);
+	if (result.success) return {
+		success: true,
+		output: result.output
+	};
+	return {
+		success: false,
+		issues: result.issues.map((issue) => ({
+			path: issue.path?.map((item) => String(item.key)).join(".") ?? "",
+			message: issue.message
+		}))
+	};
+}
+//#endregion
+//#region src/project/batch.ts
+function isLeaf(value) {
+	return value === null || typeof value !== "object";
+}
+/** Parses the batch shape `{ "<locale>": { "<key>": "<value>" } }` (as in `x18n apply`) into set ops. */
+function parseMessageBatch(project, data) {
+	if (!isJsonObject(data)) throw new X18nError("X18N4008", "expected { \"<locale>\": { \"<key>\": \"<value>\" } }");
+	const ops = [];
+	for (const [locale, entries] of Object.entries(data)) {
+		if (!isJsonObject(entries)) throw new X18nError("X18N4008", `"${locale}" must map keys to values`);
+		for (const [raw, value] of Object.entries(entries)) {
+			if (!isLeaf(value)) throw new X18nError("X18N4008", `"${locale}.${raw}" must be a string, number, boolean or null`);
+			ops.push({
+				type: "set",
+				key: project.parseKey(raw),
+				locale,
+				value
+			});
+		}
+	}
+	return ops;
+}
+/**
+* Compares the placeholders of a target value with its source. Key references (`@:key`) are not
+* parameters, and implicit names (vue-i18n `{n}` in plural messages) may be left out. Build it once per run.
+*/
+function createPlaceholderComparer(syntaxes, find = (value) => syntaxes.flatMap((s) => s.find(value))) {
+	const references = new Set(syntaxes.filter((s) => s.reference).map((s) => s.id));
+	const implicit = new Set(syntaxes.flatMap((s) => s.implicit ?? []));
+	const seen = /* @__PURE__ */ new Map();
+	const names = (text) => {
+		let found = seen.get(text);
+		if (!found) {
+			found = new Set(find(text).filter((p) => !references.has(p.syntax) && !implicit.has(p.name)).map((p) => p.name));
+			seen.set(text, found);
+		}
+		return found;
+	};
+	return (source, target) => {
+		const expected = names(source);
+		const actual = names(target);
+		return {
+			missing: [...expected].filter((name) => !actual.has(name)).sort(),
+			extra: [...actual].filter((name) => !expected.has(name)).sort()
+		};
+	};
+}
+function placeholderProblems(project, ops) {
+	const compare = createPlaceholderComparer(project.placeholderSyntaxes);
+	return ops.flatMap((op) => {
+		if (op.type !== "set" || op.locale === project.sourceLocale || typeof op.value !== "string") return [];
+		const source = project.message(op.key, project.sourceLocale)?.value;
+		if (typeof source !== "string") return [];
+		const { missing, extra } = compare(source, op.value);
+		return missing.length || extra.length ? [{
+			key: op.key,
+			locale: op.locale,
+			missing,
+			extra
+		}] : [];
+	});
+}
+//#endregion
+//#region src/project/history.ts
+const localChange = { updatedAt: Number.POSITIVE_INFINITY };
+/** A target message is stale when it last changed before its source message. */
+function isOutdated(source, target) {
+	return source !== void 0 && target !== void 0 && target.updatedAt < source.updatedAt;
+}
+function createHistory(input) {
+	const { providers } = input;
+	let histories = [];
+	let loading;
+	let watchers;
+	async function reload() {
+		const ctx = input.context();
+		histories = (await Promise.all(providers.map((provider) => provider.load(ctx).catch((error) => {
+			input.logger?.warn(`History provider "${provider.id}" failed: ${error instanceof Error ? error.message : String(error)}`);
+		})))).filter((history) => history !== void 0);
+		input.onLoad();
+	}
+	const owner = (key, locale) => {
+		for (const history of histories) {
+			const change = history.changes.get(key)?.get(locale);
+			if (change) return {
+				history,
+				change
+			};
+		}
+	};
+	return {
+		load(options) {
+			if (providers.length === 0) return Promise.resolve();
+			loading ??= reload();
+			if (options.watch && !watchers) {
+				const ctx = input.context();
+				watchers = providers.flatMap((provider) => provider.watch ? [provider.watch(ctx, () => {
+					loading = reload();
+				})] : []);
+			}
+			return loading;
+		},
+		get(key, locale) {
+			const change = owner(key, locale)?.change;
+			if (!change) return void 0;
+			const current = input.current(key, locale);
+			return change.value !== void 0 && current !== void 0 && current !== change.value ? localChange : change;
+		},
+		valueAt: (key, locale, at) => owner(key, locale)?.history.valueAt?.(key, locale, at),
+		dispose() {
+			watchers?.forEach((watcher) => watcher.dispose());
+			watchers = void 0;
+		}
+	};
+}
+//#endregion
+//#region src/project/analysis.ts
+function levelOf(setting) {
+	if (setting === void 0) return void 0;
+	if (typeof setting === "string") return {
+		level: setting,
+		options: {}
+	};
+	return {
+		level: setting[0],
+		options: setting[1]
+	};
+}
+function computeCoverage(state, reference) {
+	const { messages, sourceLocale } = state;
+	return state.locales.map((locale) => {
+		const missing = [];
+		const empty = [];
+		const outdated = [];
+		for (const key of reference) {
+			const value = messages.get(key)?.get(locale)?.[0]?.value;
+			if (value === void 0) missing.push(key);
+			else if (value === "") empty.push(key);
+			else if (locale !== sourceLocale && isOutdated(state.history(key, sourceLocale), state.history(key, locale))) outdated.push(key);
+		}
+		return {
+			locale,
+			total: reference.length,
+			translated: reference.length - missing.length - empty.length,
+			missing,
+			empty,
+			outdated
+		};
+	});
+}
+function errorDiagnostics(state) {
+	return [
+		...state.discoveryErrors,
+		...state.resourceErrors,
+		...state.scanErrors
+	].map(({ error, path }) => ({
+		code: "invalid-resource",
+		severity: error.code.startsWith("X18N3") ? "warning" : "error",
+		message: `${error.message} (${error.code})`,
+		key: void 0,
+		locale: void 0,
+		location: {
+			path,
+			range: {
+				start: 0,
+				end: 0
+			}
+		},
+		fixes: []
+	}));
+}
+function* runCheck(check, level, inputs, input) {
+	const { state, config } = input;
+	const resourcePath = (id) => state.resources.find((s) => s.resource.id === id)?.resource.path ?? id;
+	for (const item of inputs) {
+		if (item.key !== void 0 && input.ignored(item.key)) continue;
+		const severity = config.strict && (item.severity ?? level) === "warning" ? "error" : item.severity ?? level;
+		let location = item.location;
+		if (!location && item.key !== void 0) {
+			const byLocale = state.messages.get(item.key);
+			const found = byLocale?.get(item.locale ?? state.sourceLocale)?.[0] ?? byLocale?.get(state.sourceLocale)?.[0];
+			if (found) location = {
+				path: resourcePath(found.resource),
+				range: found.range?.key ?? {
+					start: 0,
+					end: 0
+				}
+			};
+		}
+		yield {
+			code: check.id,
+			severity,
+			message: item.message,
+			key: item.key,
+			locale: item.locale,
+			location,
+			fixes: item.fixes ?? []
+		};
+	}
+}
+function runChecks(input) {
+	const out = [];
+	for (const check of input.registry.checks.values()) {
+		const setting = levelOf(input.config.checks[check.id]) ?? {
+			level: check.defaultSeverity,
+			options: {}
+		};
+		if (setting.level === "off") continue;
+		try {
+			out.push(...runCheck(check, setting.level, check.run({
+				...input.ctx,
+				options: setting.options
+			}), input));
+		} catch (error) {
+			out.push({
+				code: check.id,
+				severity: "error",
+				message: `Check failed: ${error instanceof Error ? error.message : String(error)}`,
+				key: void 0,
+				locale: void 0,
+				location: void 0,
+				fixes: []
+			});
+		}
+	}
+	return out;
+}
+function createAnalyzer(options) {
+	const { config, registry } = options;
+	let memo;
+	const ignored = keyMatcher(config.ignoreKeys);
+	const inUse = keyMatcher(config.usage.keysInUse);
+	const placeholderCache = /* @__PURE__ */ new Map();
+	function analyze() {
+		const state = options.state();
+		if (memo && memo.revision === state.revision) return memo;
+		const { sourceLocale, locales, messages } = state;
+		const sourceKeys = [...messages.keys()].filter((key) => messages.get(key)?.has(sourceLocale)).sort();
+		const allKeys = [...messages.keys()].sort();
+		const coverage = computeCoverage(state, sourceKeys.length > 0 ? sourceKeys : allKeys);
+		const isDefined = (key) => messages.get(key)?.has(sourceLocale) === true || state.parents.has(key) || (state.derived.get(key)?.length ?? 0) > 0 || sourceKeys.length === 0 && messages.has(key);
+		const hasScanners = state.files.size > 0;
+		const referenceSyntaxes = registry.placeholders.filter((syntax) => syntax.reference);
+		const referenced = /* @__PURE__ */ new Set();
+		if (referenceSyntaxes.length > 0) for (const byLocale of messages.values()) {
+			const value = byLocale.get(sourceLocale)?.[0]?.value;
+			if (typeof value === "string") referenceSyntaxes.forEach((syntax) => syntax.find(value).forEach((p) => referenced.add(p.name)));
+		}
+		const prefixes = [...new Set(state.prefixUsages.flatMap((usage) => usage.key === void 0 ? [] : [usage.key]))];
+		const isUsed = (key) => {
+			if (state.usagesByKey.has(key) || inUse(key) || referenced.has(key)) return true;
+			const base = options.baseOf(key);
+			if (base !== void 0 && (state.usagesByKey.has(base) || inUse(base))) return true;
+			return prefixes.some((prefix) => key.startsWith(prefix));
+		};
+		const unused = hasScanners ? allKeys.filter((key) => !isUsed(key)) : [];
+		const undefinedUsages = state.usages.filter((usage) => usage.dynamic === false && usage.key !== void 0 && !isDefined(usage.key));
+		const placeholders = (value) => {
+			let found = placeholderCache.get(value);
+			if (!found) {
+				found = registry.placeholders.flatMap((syntax) => syntax.find(value)).sort((a, b) => a.range.start - b.range.start);
+				if (placeholderCache.size > 1e5) placeholderCache.clear();
+				placeholderCache.set(value, found);
+			}
+			return found;
+		};
+		const baseCtx = {
+			config,
+			sourceLocale,
+			locales,
+			resources: state.resources.map((s) => s.resource),
+			hasScanners,
+			keys: () => allKeys,
+			*messages(locale) {
+				for (const byLocale of messages.values()) for (const [code, list] of byLocale) if (locale === void 0 || code === locale) yield list[0];
+			},
+			message: (key, locale) => messages.get(key)?.get(locale)?.[0],
+			duplicates: (key, locale) => messages.get(key)?.get(locale) ?? [],
+			usages: () => state.usages,
+			coverage: () => coverage,
+			unused: () => unused,
+			undefinedUsages: () => undefinedUsages,
+			placeholders,
+			placeholderSyntaxes: registry.placeholders,
+			syntaxErrors: (value) => registry.placeholders.flatMap((syntax) => syntax.validate?.(value) ?? []),
+			localeInfo: options.localeInfo,
+			text: options.text,
+			history: state.history,
+			*hardStrings() {
+				for (const [path, file] of state.files) for (const hard of file.result.hardStrings ?? []) yield {
+					...hard,
+					path
+				};
+			}
+		};
+		const diagnostics = [...errorDiagnostics(state), ...runChecks({
+			config,
+			registry,
+			ctx: baseCtx,
+			state,
+			ignored
+		})];
+		diagnostics.sort((a, b) => (a.location?.path ?? "").localeCompare(b.location?.path ?? "") || (a.location?.range.start ?? 0) - (b.location?.range.start ?? 0) || a.code.localeCompare(b.code));
+		memo = {
+			revision: state.revision,
+			diagnostics,
+			coverage,
+			unused,
+			undefinedUsages
+		};
+		return memo;
+	}
+	return { analyze };
+}
+//#endregion
+//#region src/project/planner.ts
+const safeSegment = /^[\w-]+$/;
+const safeFlat = /^[\w.-]+$/;
+function commonPrefix(a, b) {
+	let i = 0;
+	while (i < a.length && i < b.length && a[i] === b[i]) i++;
+	return i;
+}
+function nodeAt(tree, path) {
+	let node = tree;
+	for (const segment of path) {
+		if (node === void 0 || isMessageLeaf(node)) return void 0;
+		node = node[segment];
+	}
+	return node;
+}
+/** True for flat files (`{ "a.b": "x" }`), false for nested ones, undefined when it cannot tell. */
+function isFlatTree(tree) {
+	const entries = Object.entries(tree);
+	if (entries.length === 0) return void 0;
+	if (entries.some(([, value]) => !isMessageLeaf(value))) return false;
+	return entries.some(([key]) => key.includes(".")) ? true : void 0;
+}
+/** The longest key prefix a tree shares with `path`. */
+function longestPrefix(tree, prefix, path) {
+	let best = 0;
+	for (const [segment, child] of Object.entries(tree)) {
+		const next = [...prefix, ...segment.split(".")];
+		best = Math.max(best, commonPrefix(next, path));
+		if (!isMessageLeaf(child)) best = Math.max(best, longestPrefix(child, next, path));
+	}
+	return best;
+}
+function mirrorPath(path, from, to) {
+	const escaped = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return path.replace(new RegExp(`(^|[/._-])${escaped}(?=$|[/._-])`, "g"), `$1${to}`);
+}
+function importEdit(text, lines) {
+	const missing = lines.filter((line) => !text.includes(line.trim()));
+	if (missing.length === 0) return void 0;
+	const script = /<script\b[^>]*>\r?\n?/.exec(text);
+	let at = 0;
+	if (script) at = script.index + script[0].length;
+	else {
+		const last = [...text.matchAll(/^import\s.*$/gm)].at(-1);
+		if (last) at = last.index + last[0].length + 1;
+	}
+	return {
+		range: {
+			start: at,
+			end: at
+		},
+		text: `${missing.join("\n")}\n`
+	};
+}
+var PlanBuilder = class {
+	options;
+	state;
+	answers;
+	work = /* @__PURE__ */ new Map();
+	created = /* @__PURE__ */ new Map();
+	sourceEdits = /* @__PURE__ */ new Map();
+	sourceImports = /* @__PURE__ */ new Map();
+	decisions = [];
+	warnings = [];
+	touched = /* @__PURE__ */ new Set();
+	stateById;
+	config;
+	constructor(options, state, answers) {
+		this.options = options;
+		this.state = state;
+		this.answers = answers;
+		this.config = options.config;
+		this.stateById = new Map(state.resources.map((s) => [s.resource.id, s]));
+	}
+	/** ---- Targets ---- */
+	targetOf(s) {
+		const format = this.options.registry.formatById(s.resource.format);
+		if (!format) throw new X18nError("X18N2001", s.resource.path);
+		return {
+			id: s.resource.id,
+			path: s.resource.path,
+			locale: s.resource.locale,
+			namespace: s.resource.namespace,
+			format,
+			state: s
+		};
+	}
+	workFor(target) {
+		let entry = this.work.get(target.id);
+		if (!entry) {
+			entry = {
+				target,
+				tree: target.state?.rawTree ?? {},
+				ops: [],
+				keyRenames: [],
+				formatOnly: false
+			};
+			this.work.set(target.id, entry);
+		}
+		return entry;
+	}
+	writable(id) {
+		const s = this.stateById.get(id);
+		if (s.resource.readonly) throw new X18nError("X18N4001", s.resource.path);
+		return s;
+	}
+	keyId(key) {
+		const id = splitKey(key, this.state.namespaced);
+		return {
+			namespace: id.namespace,
+			path: [...id.path]
+		};
+	}
+	/** Key path relative to a resource, or undefined when the key does not belong there. */
+	relativePath(key, target) {
+		const { namespace, path } = this.keyId(key);
+		const fallback = this.config.namespace.default;
+		if (this.state.namespaced) return (namespace ?? fallback) === (target.namespace ?? fallback) ? path : void 0;
+		const prefix = target.namespace ? target.namespace.split(".") : [];
+		if (path.length <= prefix.length || prefix.some((segment, i) => path[i] !== segment)) return void 0;
+		return path.slice(prefix.length);
+	}
+	storedPathFor(entry, relative) {
+		const stored = this.options.toStored(entry.target, relative);
+		return stored.length === relative.length && (isFlatTree(entry.tree) ?? this.config.keyStyle === "flat") ? [stored.join(".")] : stored;
+	}
+	createTarget(key, locale) {
+		const { resources, sourceLocale, namespaced } = this.state;
+		const fits = (s) => this.relativePath(key, s.resource) !== void 0;
+		const source = this.options.message(key, sourceLocale);
+		const sourceState = source && this.stateById.get(source.resource);
+		const namespace = namespaced ? this.keyId(key).namespace ?? this.config.namespace.default : sourceState?.resource.namespace;
+		const exists = (path) => resources.some((r) => r.resource.path === path);
+		const resolved = this.options.resolveNew(locale, namespace);
+		if (resolved && !exists(resolved)) {
+			const format = this.options.registry.formatFor(resolved);
+			if (format?.serialize) {
+				const target = {
+					id: resolved,
+					path: resolved,
+					locale,
+					namespace,
+					format,
+					state: void 0
+				};
+				this.created.set(resolved, target);
+				return target;
+			}
+		}
+		const sibling = (r) => r.resource.locale === locale && r.resource.namespace !== void 0 && namespace !== void 0;
+		const model = (sourceState && fits(sourceState) ? sourceState : void 0) ?? resources.find((s) => s.resource.locale === sourceLocale && fits(s)) ?? resources.find(fits) ?? resources.find(sibling);
+		const format = model && this.options.registry.formatById(model.resource.format);
+		let path = model && mirrorPath(model.resource.path, model.resource.locale, locale);
+		if (model && path && namespace !== void 0 && model.resource.namespace !== void 0 && model.resource.namespace !== namespace) path = mirrorPath(path, model.resource.namespace, namespace);
+		if (!model || !format?.serialize || model.resource.block || !path || exists(path)) throw new X18nError("X18N4005", `${key} in ${locale}`);
+		const target = {
+			id: path,
+			path,
+			locale,
+			namespace: namespace ?? model.resource.namespace,
+			format,
+			state: void 0
+		};
+		this.created.set(path, target);
+		return target;
+	}
+	/** Placement: the namespace's resource, then the longest shared prefix, then the first; a tie is a decision. */
+	pickTarget(key, locale) {
+		let inLocale = this.state.resources.filter((s) => s.resource.locale === locale && this.relativePath(key, s.resource) !== void 0);
+		const source = this.options.message(key, this.state.sourceLocale);
+		const sourceNamespace = source && this.stateById.get(source.resource)?.resource.namespace;
+		if (sourceNamespace !== void 0 && !this.state.namespaced) inLocale = inLocale.filter((s) => s.resource.namespace === sourceNamespace);
+		if (inLocale.length === 0) return [...this.created.values()].find((t) => t.locale === locale && this.relativePath(key, t) !== void 0) ?? this.createTarget(key, locale);
+		if (inLocale.length === 1) return this.targetOf(inLocale[0]);
+		const path = this.keyId(key).path;
+		const scores = inLocale.map((s) => {
+			const prefix = s.resource.namespace && !this.state.namespaced ? path.slice(0, s.resource.namespace.split(".").length) : [];
+			return {
+				s,
+				best: longestPrefix(s.tree, prefix, path)
+			};
+		});
+		const top = Math.max(...scores.map((x) => x.best));
+		const winners = scores.filter((x) => x.best === top);
+		if (winners.length === 1 || top === 0) return this.targetOf(winners[0].s);
+		const id = `target:${key}:${locale}`;
+		this.decisions.push({
+			id,
+			message: `Which file gets "${key}" in ${locale}?`,
+			options: winners.map((w) => ({
+				id: w.s.resource.id,
+				label: w.s.resource.id
+			})),
+			default: winners[0].s.resource.id
+		});
+		return this.targetOf((winners.find((w) => w.s.resource.id === this.answers[id]) ?? winners[0]).s);
+	}
+	/** ---- Message ops ---- */
+	pushOp(entry, op) {
+		entry.ops.push(op);
+		entry.tree = applyMessageOps(entry.tree, [op]);
+	}
+	setValue(key, locale, value) {
+		this.touched.add(key);
+		const existing = this.options.message(key, locale);
+		if (existing) {
+			this.pushOp(this.workFor(this.targetOf(this.writable(existing.resource))), {
+				type: "set",
+				path: existing.storedPath,
+				value
+			});
+			return;
+		}
+		const target = this.pickTarget(key, locale);
+		if (target.state) this.writable(target.state.resource.id);
+		const entry = this.workFor(target);
+		const stored = this.storedPathFor(entry, this.relativePath(key, target));
+		const occupied = nodeAt(entry.tree, stored);
+		if (occupied !== void 0 && !isMessageLeaf(occupied)) this.warnings.push(`"${key}" is a parent of other keys in ${target.path}; they are replaced.`);
+		this.pushOp(entry, {
+			type: "set",
+			path: stored,
+			value
+		});
+	}
+	deleteMessage(m) {
+		const entry = this.workFor(this.targetOf(this.writable(m.resource)));
+		let path = [...m.storedPath];
+		while (path.length > 1) {
+			const parent = nodeAt(entry.tree, path.slice(0, -1));
+			if (parent === void 0 || isMessageLeaf(parent) || Object.keys(parent).length > 1) break;
+			path = path.slice(0, -1);
+		}
+		this.pushOp(entry, {
+			type: "delete",
+			path
+		});
+	}
+	/** Renames a key in every locale, in place when only the last segment changes. */
+	/**
+	* Renames a parent object in place where only its last segment changes, so the subtree keeps its
+	* position and layout. Returns the resources it handled.
+	*/
+	renameNode(from, to) {
+		const handled = /* @__PURE__ */ new Set();
+		for (const s of this.state.resources) {
+			const relativeFrom = this.relativePath(from, s.resource);
+			const relativeTo = this.relativePath(to, s.resource);
+			if (!relativeFrom || !relativeTo || s.resource.readonly || !this.options.registry.formatById(s.resource.format)?.edit) continue;
+			const stored = s.toStored(relativeFrom);
+			const next = s.toStored(relativeTo);
+			const node = nodeAt(s.rawTree, stored);
+			const range = s.ranges.get(pathId(stored));
+			const last = next.at(-1);
+			const sameParent = next.length === stored.length && next.slice(0, -1).every((segment, i) => segment === stored[i]);
+			if (node === void 0 || isMessageLeaf(node) || !range || !sameParent || !safeSegment.test(last)) continue;
+			const entry = this.workFor(this.targetOf(s));
+			entry.keyRenames.push({
+				range: {
+					start: range.key.start + s.offset,
+					end: range.key.end + s.offset
+				},
+				text: last
+			});
+			const leaves = [...walkLeaves(node, stored)];
+			entry.tree = applyMessageOps(entry.tree, [...leaves.map((leaf) => ({
+				type: "delete",
+				path: leaf.path
+			})), ...leaves.map((leaf) => ({
+				type: "set",
+				path: [...next, ...leaf.path.slice(stored.length)],
+				value: leaf.value
+			}))]);
+			handled.add(s.resource.id);
+		}
+		return handled;
+	}
+	moveKey(from, to, renamed = /* @__PURE__ */ new Set()) {
+		this.touched.add(from);
+		this.touched.add(to);
+		for (const [locale, list] of this.options.messages(from) ?? []) {
+			const m = list[0];
+			if (renamed.has(m.resource)) continue;
+			const s = this.writable(m.resource);
+			const relative = this.relativePath(to, s.resource);
+			if (!relative) {
+				this.deleteMessage(m);
+				this.setValue(to, locale, m.value);
+				continue;
+			}
+			const entry = this.workFor(this.targetOf(s));
+			const flat = m.storedPath.length === 1 && m.storedPath[0].includes(".");
+			const next = flat ? [relative.join(".")] : this.options.toStored(s.resource, relative);
+			const sameParent = next.length === m.storedPath.length && next.slice(0, -1).every((segment, i) => segment === m.storedPath[i]);
+			const last = next.at(-1);
+			if (sameParent && m.range && (flat ? safeFlat : safeSegment).test(last)) {
+				entry.keyRenames.push({
+					range: m.range.key,
+					text: last
+				});
+				entry.tree = applyMessageOps(entry.tree, [{
+					type: "delete",
+					path: m.storedPath
+				}, {
+					type: "set",
+					path: next,
+					value: m.value
+				}]);
+				continue;
+			}
+			this.deleteMessage(m);
+			this.pushOp(entry, {
+				type: "set",
+				path: this.storedPathFor(entry, relative),
+				value: m.value
+			});
+		}
+	}
+	/** The raw text a usage needs to refer to `next`, given its scope. */
+	rawFor(usage, next) {
+		if (usage.raw.startsWith(".") && usage.key?.endsWith(usage.raw)) {
+			const scope = usage.key.slice(0, usage.key.length - usage.raw.length);
+			if (next.startsWith(`${scope}.`)) return next.slice(scope.length);
+		}
+		const { namespace, path } = this.keyId(next);
+		let rest = path.join(".");
+		const separator = this.config.namespace.separator;
+		const explicit = this.state.namespaced && usage.raw.indexOf(separator) > 0;
+		if (usage.scopePrefix && !explicit) {
+			if (!rest.startsWith(`${usage.scopePrefix}.`)) return void 0;
+			rest = rest.slice(usage.scopePrefix.length + 1);
+		}
+		if (!this.state.namespaced) return rest;
+		if (explicit || namespace !== (usage.scopeNamespace ?? this.config.namespace.default)) return `${namespace}${separator}${rest}`;
+		return rest;
+	}
+	editSource(path, edit) {
+		const list = this.sourceEdits.get(path) ?? [];
+		this.sourceEdits.set(path, list);
+		if (!list.some((e) => e.range.start === edit.range.start && e.range.end === edit.range.end)) list.push(edit);
+	}
+	rewriteUsages(from, to) {
+		for (const { usage, possible } of this.options.usageMatches({ key: from })) {
+			if (possible || usage.key !== from) continue;
+			const raw = this.rawFor(usage, to);
+			if (raw === void 0) this.warnings.push(`${usage.path}: usage of "${from}" is under the key prefix "${usage.scopePrefix}" and was not updated.`);
+			else this.editSource(usage.path, {
+				range: usage.range,
+				text: raw
+			});
+		}
+	}
+	/** Rewrites the static part of prefix usages under `from`, and warns about the ones it cannot follow. */
+	rewritePrefixUsages(from, to) {
+		for (const { usage, possible } of this.options.usageMatches({ prefix: from })) {
+			if (!possible || usage.key === void 0) continue;
+			const raw = usage.key.startsWith(from) ? this.rawFor(usage, to + usage.key.slice(from.length)) : void 0;
+			if (raw === void 0) this.warnings.push(`${usage.path}: dynamic usage "${usage.raw}" may refer to renamed keys and was not updated.`);
+			else this.editSource(usage.path, {
+				range: usage.range,
+				text: raw
+			});
+		}
+	}
+	/** ---- Ops ---- */
+	conflictCheck(to) {
+		const existing = this.options.messages(to);
+		if (!existing && !this.options.parents().has(to)) return;
+		const files = [...new Set([...existing?.values() ?? []].flatMap((list) => list.map((m) => this.stateById.get(m.resource)?.resource.path ?? m.resource)))];
+		throw new X18nError("X18N4002", `"${to}"${files.length ? ` in ${files.join(", ")}` : ""}`, files);
+	}
+	rename(op) {
+		if (op.from === op.to) return;
+		const all = this.options.allKeys();
+		const isLeaf = this.options.messages(op.from) !== void 0;
+		const under = all.filter((key) => isKeyUnder(key, op.from));
+		const derived = all.filter((key) => this.options.baseOf(key) === op.from);
+		let keys;
+		if (op.type === "rename-prefix") keys = under;
+		else if (isLeaf) keys = [op.from, ...derived];
+		else keys = under.length > 0 ? under : derived;
+		if (keys.length === 0) throw new X18nError("X18N4006", op.from);
+		const pairs = keys.map((key) => [key, replaceKeyPrefix(key, op.from, op.to)]);
+		for (const [, to] of pairs) this.conflictCheck(to);
+		const renamed = keys.includes(op.from) ? /* @__PURE__ */ new Set() : this.renameNode(op.from, op.to);
+		for (const [from, to] of pairs) {
+			this.moveKey(from, to, renamed);
+			if (op.usages !== false) this.rewriteUsages(from, to);
+		}
+		if (op.usages === false) return;
+		if (!keys.includes(op.from)) this.rewriteUsages(op.from, op.to);
+		this.rewritePrefixUsages(op.from, op.to);
+	}
+	delete(op) {
+		const keys = this.options.messages(op.key) ? [op.key] : this.options.allKeys().filter((key) => isKeyUnder(key, op.key));
+		if (keys.length === 0) throw new X18nError("X18N4006", op.key);
+		for (const key of keys) {
+			this.touched.add(key);
+			for (const [locale, list] of this.options.messages(key) ?? []) if (op.locales === void 0 || op.locales === "all" || op.locales.includes(locale)) list.forEach((m) => this.deleteMessage(m));
+			const used = this.options.usageMatches({ key }).filter((match) => !match.possible).length;
+			if (used > 0) this.warnings.push(`"${key}" still has ${used} usage${used === 1 ? "" : "s"}.`);
+		}
+	}
+	extract(items) {
+		for (const item of items) {
+			if (!this.options.message(item.key, this.state.sourceLocale)) this.setValue(item.key, this.state.sourceLocale, item.value);
+			this.editSource(item.path, {
+				range: item.range,
+				text: item.replacement
+			});
+			if (item.imports?.length) {
+				const set = this.sourceImports.get(item.path) ?? /* @__PURE__ */ new Set();
+				this.sourceImports.set(item.path, set);
+				item.imports.forEach((line) => set.add(line));
+			}
+		}
+	}
+	run(ops) {
+		for (const op of ops) switch (op.type) {
+			case "set":
+				this.setValue(op.key, op.locale, op.value);
+				if (this.config.write.keepFilled) {
+					for (const locale of this.state.locales) if (locale !== op.locale && !this.options.message(op.key, locale)) this.setValue(op.key, locale, "");
+				}
+				break;
+			case "delete":
+				this.delete(op);
+				break;
+			case "rename":
+			case "rename-prefix":
+				this.rename(op);
+				break;
+			case "extract":
+				this.extract(op.items);
+				break;
+			case "format": for (const s of this.state.resources) if ((!op.paths || op.paths.includes(s.resource.path)) && !s.resource.readonly && !s.error) this.workFor(this.targetOf(s)).formatOnly = true;
+		}
+	}
+	/** ---- Changes ---- */
+	compare() {
+		return this.config.write.sort === "locale" ? (a, b) => a.localeCompare(b) : (a, b) => a < b ? -1 : a > b ? 1 : 0;
+	}
+	/** The new content of one existing resource. */
+	nextContent(entry, s) {
+		const { target } = entry;
+		const ctx = {
+			path: target.path,
+			locale: target.locale,
+			namespace: target.namespace,
+			indent: this.config.write.indent
+		};
+		const sort = this.config.write.sort !== false;
+		const edit = target.format.edit;
+		if (entry.formatOnly || sort || !edit) {
+			if (!target.format.serialize) throw new X18nError("X18N4001", target.path);
+			if (!entry.formatOnly && !edit) this.warnings.push(`${target.path} was re-written in full (the ${target.format.id} format cannot edit in place); formatting was reset.`);
+			return target.format.serialize(sort || entry.formatOnly ? sortTree(entry.tree, sort ? this.compare() : () => 0) : entry.tree, ctx);
+		}
+		const local = (e) => ({
+			range: {
+				start: e.range.start - s.offset,
+				end: e.range.end - s.offset
+			},
+			text: e.text
+		});
+		if (entry.ops.length === 0) return applyTextEdits(s.content, entry.keyRenames.map(local));
+		const renameOps = [];
+		for (const rename of entry.keyRenames) {
+			const node = [...s.ranges].find(([, range]) => range.key.start + s.offset === rename.range.start);
+			if (!node) continue;
+			const oldPath = node[0].split("\0");
+			const newPath = [...oldPath.slice(0, -1), rename.text];
+			const value = nodeAt(entry.tree, newPath);
+			renameOps.push({
+				type: "delete",
+				path: oldPath
+			});
+			if (value !== void 0 && isMessageLeaf(value)) renameOps.push({
+				type: "set",
+				path: newPath,
+				value
+			});
+			else if (value !== void 0) renameOps.push(...[...walkLeaves(value, newPath)].map((leaf) => ({
+				type: "set",
+				path: leaf.path,
+				value: leaf.value
+			})));
+		}
+		return applyTextEdits(s.content, edit(s.content, [...renameOps, ...entry.ops], ctx));
+	}
+	changes() {
+		const changes = [];
+		const texts = /* @__PURE__ */ new Map();
+		const resourceEdits = /* @__PURE__ */ new Map();
+		for (const entry of this.work.values()) {
+			const { target } = entry;
+			const s = target.state;
+			if (!s) {
+				const ctx = {
+					path: target.path,
+					locale: target.locale,
+					namespace: target.namespace,
+					indent: this.config.write.indent
+				};
+				const tree = this.config.write.sort === false ? entry.tree : sortTree(entry.tree, this.compare());
+				changes.push({
+					type: "create",
+					path: target.path,
+					content: target.format.serialize(tree, ctx)
+				});
+				texts.set(target.path, void 0);
+				continue;
+			}
+			const edits = diffText(s.content, this.nextContent(entry, s)).map((e) => ({
+				range: {
+					start: e.range.start + s.offset,
+					end: e.range.end + s.offset
+				},
+				text: e.text
+			}));
+			if (edits.length === 0) continue;
+			const list = resourceEdits.get(target.path) ?? [];
+			resourceEdits.set(target.path, list);
+			list.push(...edits);
+		}
+		for (const [path, edits] of resourceEdits) {
+			changes.push({
+				type: "edit",
+				path,
+				edits
+			});
+			texts.set(path, this.state.fileTexts.get(path));
+		}
+		for (const [path, edits] of this.sourceEdits) {
+			const text = this.options.text(path);
+			const imports = this.sourceImports.get(path);
+			const extra = imports && text !== void 0 ? importEdit(text, [...imports]) : void 0;
+			changes.push({
+				type: "edit",
+				path,
+				edits: [...edits, ...extra ? [extra] : []].sort((a, b) => a.range.start - b.range.start)
+			});
+			texts.set(path, text);
+		}
+		return {
+			changes,
+			texts
+		};
+	}
+};
+function createPlanner(options) {
+	const texts = /* @__PURE__ */ new Map();
+	function planWith(ops, answers) {
+		const state = options.state();
+		const builder = new PlanBuilder(options, state, answers);
+		builder.run(ops);
+		const result = builder.changes();
+		return {
+			plan: {
+				id: hashText(JSON.stringify({
+					revision: state.revision,
+					ops,
+					answers
+				})),
+				revision: state.revision,
+				ops,
+				changes: result.changes,
+				decisions: builder.decisions,
+				warnings: builder.warnings,
+				keys: [...builder.touched].sort()
+			},
+			texts: result.texts
+		};
+	}
+	async function write(change) {
+		if (change.type === "edit") {
+			const current = await options.host.readFile(change.path);
+			await options.host.writeFile(change.path, applyTextEdits(current ?? "", change.edits));
+			return {
+				type: "change",
+				path: change.path
+			};
+		}
+		if (change.type === "create") {
+			await options.host.writeFile(change.path, change.content);
+			return {
+				type: "create",
+				path: change.path
+			};
+		}
+		await options.host.deleteFile(change.path);
+		return {
+			type: "delete",
+			path: change.path
+		};
+	}
+	return {
+		plan(ops, answers = {}) {
+			const result = planWith(ops, answers);
+			texts.set(result.plan.id, result.texts);
+			return result.plan;
+		},
+		async apply(plan, answers) {
+			const unanswered = plan.decisions.filter((d) => answers[d.id] === void 0);
+			if (unanswered.length > 0) throw new X18nError("X18N4003", unanswered.map((d) => d.message).join(" "), unanswered.map((d) => d.id));
+			if (plan.revision !== options.state().revision) throw new X18nError("X18N4004");
+			const fresh = plan.decisions.length > 0 ? planWith(plan.ops, answers) : {
+				plan,
+				texts: texts.get(plan.id) ?? /* @__PURE__ */ new Map()
+			};
+			for (const change of fresh.plan.changes) {
+				const current = await options.host.readFile(change.path);
+				const expected = fresh.texts.get(change.path);
+				if (change.type === "edit" && expected !== void 0 && current !== expected || change.type === "create" && current !== void 0) throw new X18nError("X18N4004", change.path);
+			}
+			const events = [];
+			for (const change of fresh.plan.changes) events.push(await write(change));
+			texts.delete(plan.id);
+			return {
+				revision: (await options.update(events))?.revision ?? options.state().revision,
+				changes: fresh.plan.changes
+			};
+		}
+	};
+}
+//#endregion
+//#region src/project/prompt.ts
+function text(value) {
+	return value === void 0 || value === null ? void 0 : String(value);
+}
+function contextOf(project, key) {
+	return project.usages({ key }).slice(0, 2).flatMap(({ usage }) => {
+		const source = project.text(usage.path);
+		if (source === void 0) return [];
+		const index = createLineIndex(source);
+		const line = index.position(usage.range.start).line;
+		const lines = [
+			line - 1,
+			line,
+			line + 1
+		].filter((n) => n >= 0 && n < index.lineCount).map((n) => index.line(n));
+		return [{
+			path: usage.path,
+			line: line + 1,
+			snippet: lines.join("\n")
+		}];
+	});
+}
+/** Builds the parts of a translate or review prompt from project state. */
+function buildPrompt(project, kind, to, options, extra) {
+	const from = project.sourceLocale;
+	const match = typeof options.keys === "string" ? keyMatcher([options.keys]) : void 0;
+	const list = Array.isArray(options.keys) ? new Set(options.keys) : void 0;
+	const stale = (key) => isOutdated(project.history(key, from), project.history(key, to));
+	const candidates = project.keys({ namespace: options.namespace }).filter((key) => {
+		if (match && !match(key)) return false;
+		if (list && !list.has(key)) return false;
+		const source = text(project.message(key, from)?.value);
+		if (source === void 0 || source === "") return false;
+		const target = text(project.message(key, to)?.value);
+		if (kind === "review") return target !== void 0 && target !== "";
+		return list !== void 0 || target === void 0 || target === "" || options.stale === true && stale(key);
+	});
+	const start = Number(options.cursor ?? 0) || 0;
+	const limit = options.limit ?? 50;
+	const page = candidates.slice(start, start + limit);
+	const end = start + page.length;
+	const syntaxes = project.placeholderSyntaxes;
+	const info = project.localeInfo(to);
+	const draft = {
+		rules: [],
+		notes: []
+	};
+	if (syntaxes.length > 0) draft.rules.push(`Keep every placeholder exactly as written (${syntaxes.map((s) => `\`${s.example ?? s.id}\``).join(", ")}); do not translate their names.`);
+	draft.rules.push("Keep markup tags and their attributes as they are.", "Match the tone and wording of the existing messages in the target locale.", "Do not translate glossary terms marked \"do not translate\".");
+	if (info.pluralCategories.length > 1) draft.notes.push(`${to} uses the plural categories ${info.pluralCategories.join(", ")}.`);
+	for (const hook of extra.hooks) hook(draft, {
+		sourceLocale: from,
+		targetLocale: to,
+		localeInfo: info
+	});
+	const examples = kind === "translate" ? project.keys().flatMap((key) => {
+		const source = text(project.message(key, from)?.value);
+		const target = text(project.message(key, to)?.value);
+		return source && target && !candidates.includes(key) ? [{
+			key,
+			source,
+			target
+		}] : [];
+	}).slice(0, 5) : [];
+	const items = page.map((key) => {
+		const source = text(project.message(key, from)?.value) ?? "";
+		const translated = project.history(key, to);
+		const previous = translated && stale(key) ? text(project.valueAt(key, from, translated.updatedAt)) : void 0;
+		return {
+			key,
+			source,
+			placeholders: [...new Set(syntaxes.flatMap((s) => s.find(source)).map((p) => p.text))],
+			existing: text(project.message(key, to)?.value) || void 0,
+			previousSource: previous === source ? void 0 : previous,
+			context: options.context === false ? [] : contextOf(project, key)
+		};
+	});
+	const nextCursor = end < candidates.length ? String(end) : void 0;
+	const instructions = kind === "translate" ? [
+		`Write a JSON file \`{ "${to}": { "<key>": "<translation>" } }\` and run \`x18n apply <file> --json\`, or run \`x18n set <key> --locale ${to} --value <text>\` per key.`,
+		`Then run \`x18n check --only placeholder-mismatch,invalid-syntax --locale ${to} --json\` and fix the reported keys.`,
+		nextCursor ? `${candidates.length - end} more keys remain: \`x18n prompt translate --to ${to} --cursor ${nextCursor}\`.` : `To find more work: \`x18n keys --missing ${to} --json --limit 50\`.`
+	] : [`Fix wrong translations with \`x18n set <key> --locale ${to} --value <text>\`, then list what you changed and why.`, `Then run \`x18n check --only placeholder-mismatch,invalid-syntax --locale ${to} --json\`.`];
+	return {
+		kind,
+		project: project.name,
+		from,
+		to,
+		targetName: info.displayName,
+		total: candidates.length,
+		remaining: candidates.length - end,
+		nextCursor,
+		rules: draft.rules,
+		notes: draft.notes,
+		glossary: extra.config.glossary.map((entry) => ({
+			term: entry.term,
+			translation: entry.translations?.[to],
+			note: entry.note,
+			doNotTranslate: entry.doNotTranslate === true
+		})),
+		examples,
+		items,
+		instructions
+	};
+}
+function renderItem(item, to) {
+	const out = [
+		`### \`${item.key}\``,
+		"",
+		`- Source: ${JSON.stringify(item.source)}`
+	];
+	if (item.placeholders.length) out.push(`- Placeholders: ${item.placeholders.map((p) => `\`${p}\``).join(", ")}`);
+	if (item.previousSource !== void 0) out.push(`- Source when ${to} last changed: ${JSON.stringify(item.previousSource)}`);
+	if (item.existing !== void 0) out.push(`- Current ${to}: ${JSON.stringify(item.existing)}`);
+	for (const context of item.context) out.push(`- Used in \`${context.path}:${context.line}\`:`, "", "  ```", ...context.snippet.split("\n").map((line) => `  ${line}`), "  ```");
+	out.push("");
+	return out;
+}
+/** Plain markdown, with no provider-specific syntax. */
+function renderPrompt(data) {
+	const target = data.targetName ? `${data.to} (${data.targetName})` : data.to;
+	const out = [];
+	if (data.kind === "translate") out.push(`# Translate ${data.items.length} messages from ${data.from} to ${target}`, "");
+	else out.push(`# Review ${data.items.length} ${target} translations against ${data.from}`, "", "Check meaning, placeholders, glossary terms, tone and length. Report and fix wrong translations.", "");
+	if (data.items.length === 0) return `${out.join("\n")}Nothing to do: every key is ${data.kind === "translate" ? "translated" : "reviewed"}.\n`;
+	out.push("## Rules", "", ...data.rules.map((rule) => `- ${rule}`), ...data.notes.map((note) => `- ${note}`), "");
+	if (data.glossary.length > 0) {
+		out.push("## Glossary", "");
+		for (const entry of data.glossary) out.push(`- ${entry.term}${entry.doNotTranslate ? ": do not translate" : entry.translation ? ` → ${entry.translation}` : ""}${entry.note ? ` (${entry.note})` : ""}`);
+		out.push("");
+	}
+	if (data.examples.length > 0) {
+		out.push(`## Existing ${data.to} messages (style reference)`, "");
+		for (const example of data.examples) out.push(`- \`${example.key}\`: ${JSON.stringify(example.source)} → ${JSON.stringify(example.target)}`);
+		out.push("");
+	}
+	out.push("## Messages", "", ...data.items.flatMap((item) => renderItem(item, data.to)));
+	out.push("## How to write results", "", ...data.instructions.map((line) => `- ${line}`), "");
+	if (data.remaining > 0) out.push(`This prompt holds ${data.items.length} of ${data.total} messages.`, "");
+	return out.join("\n");
+}
+//#endregion
+//#region src/project/usages.ts
+function innermost(scopes, range) {
+	let best;
+	for (const scope of scopes) if (scope.range.start <= range.start && scope.range.end >= range.end && (!best || scope.range.end - scope.range.start < best.range.end - best.range.start)) best = scope;
+	return best;
+}
+function createUsageResolver(config, namespaced, normalizers) {
+	const separator = config.namespace.separator;
+	return { resolve(candidate, scopes, path, scanner) {
+		const scope = innermost(scopes, candidate.range);
+		const ctx = { path };
+		let text = candidate.raw;
+		for (const normalize of normalizers) {
+			const result = normalize(text, ctx);
+			if (result !== void 0) {
+				text = result;
+				break;
+			}
+		}
+		const scopeNamespace = candidate.namespace ?? scope?.namespace;
+		const scopePrefix = candidate.keyPrefix ?? scope?.keyPrefix;
+		let namespace;
+		let explicit = false;
+		if (namespaced) {
+			const index = text.indexOf(separator);
+			explicit = index > 0;
+			if (explicit) {
+				namespace = text.slice(0, index);
+				text = text.slice(index + separator.length);
+			} else namespace = scopeNamespace ?? config.namespace.default;
+		}
+		if (scopePrefix && !explicit) text = text ? `${scopePrefix}.${text}` : scopePrefix;
+		let key;
+		if (candidate.dynamic === "unknown") key = void 0;
+		else key = joinKey(namespace, text === "" ? [] : text.split("."));
+		return {
+			key,
+			raw: candidate.raw,
+			path,
+			range: candidate.range,
+			scanner,
+			kind: candidate.kind,
+			dynamic: candidate.dynamic,
+			locale: candidate.locale,
+			scopeNamespace,
+			scopePrefix
+		};
+	} };
+}
+/** True when a prefix usage may refer to `key`. The key of `t(`pages.${id}`)` is `pages.`, so only children match. */
+function prefixMatches(usage, key) {
+	return usage.dynamic === "prefix" && usage.key !== void 0 && key.startsWith(usage.key);
+}
+/** Ranges covered by `x18n-disable-next-line` and `x18n-disable` ... `x18n-enable` comments. */
+function suppressedRanges(text) {
+	if (!text.includes("x18n-disable")) return [];
+	const ranges = [];
+	for (const match of text.matchAll(/x18n-disable-next-line/g)) {
+		const lineEnd = text.indexOf("\n", match.index);
+		if (lineEnd === -1) continue;
+		const nextEnd = text.indexOf("\n", lineEnd + 1);
+		ranges.push({
+			start: lineEnd + 1,
+			end: nextEnd === -1 ? text.length : nextEnd
+		});
+	}
+	for (const match of text.matchAll(/x18n-disable(?![-\w])/g)) {
+		const end = text.indexOf("x18n-enable", match.index);
+		ranges.push({
+			start: match.index,
+			end: end === -1 ? text.length : end
+		});
+	}
+	return ranges;
+}
+/** Compiles derived-key rules (`{key}_plural`, `{key}_*`) into a function from a key to its base key. */
+function derivedBase(rules) {
+	const regexes = rules.map((rule) => {
+		const source = rule.split("{key}").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^.:]+")).join("(.+)");
+		return new RegExp(`^${source}$`);
+	});
+	return (key) => {
+		for (const re of regexes) {
+			const match = re.exec(key);
+			if (match?.[1]) return match[1];
+		}
+	};
+}
+//#endregion
+//#region src/project/project.ts
+const scanConcurrency = 64;
+function createProject(options) {
+	const { host, setup } = options;
+	const { config, registry } = setup;
+	const listeners = /* @__PURE__ */ new Set();
+	const fileTexts = /* @__PURE__ */ new Map();
+	const resourceStates = /* @__PURE__ */ new Map();
+	const files = /* @__PURE__ */ new Map();
+	const discoveryErrors = [];
+	let duplicates = [];
+	let finderResults = [];
+	let revision = 0;
+	let namespaced = false;
+	let locales = [];
+	let sourceLocale = config.sourceLocale;
+	let resolver;
+	let watcher;
+	let usageEligible = () => false;
+	let resourceIndex;
+	let resolved = /* @__PURE__ */ new WeakMap();
+	const normalizers = registry.plugins.flatMap((plugin) => plugin.normalizeKey ? [plugin.normalizeKey] : []);
+	const transforms = registry.plugins.flatMap((plugin) => plugin.transformResource ? [plugin.transformResource] : []);
+	const localeInfoHooks = registry.plugins.flatMap((plugin) => plugin.localeInfo ? [plugin.localeInfo] : []);
+	const baseOf = derivedBase(config.usage.derivedKeys);
+	const scanSignature = hashText(JSON.stringify({
+		usage: config.usage,
+		namespace: config.namespace,
+		scanners: registry.scanners.map((s) => s.id),
+		v: 1
+	}));
+	const localeFilter = (code) => (!config.locales || config.locales.includes(code)) && !config.ignoreLocales.includes(code);
+	const infoCache = /* @__PURE__ */ new Map();
+	function localeInfo(code) {
+		let info = infoCache.get(code);
+		if (!info) {
+			info = parseLocaleInfo(code);
+			for (const hook of localeInfoHooks) {
+				const result = hook(code);
+				if (result) {
+					info = {
+						...info,
+						...result,
+						code
+					};
+					break;
+				}
+			}
+			infoCache.set(code, info);
+		}
+		return info;
+	}
+	async function discover() {
+		const ctx = {
+			host,
+			config,
+			extensions: [...new Set(registry.formats.flatMap((format) => format.extensions))]
+		};
+		const seen = /* @__PURE__ */ new Map();
+		const out = [];
+		duplicates = [];
+		finderResults = [];
+		for (const finder of registry.finders) {
+			const found = await finder.find(ctx);
+			const kept = [];
+			for (const candidate of found) {
+				const id = candidate.block ? `${candidate.path}#${candidate.block.index}` : candidate.path;
+				const previous = seen.get(id);
+				if (previous) {
+					duplicates.push({
+						path: id,
+						finder: finder.id,
+						keptFrom: previous
+					});
+					continue;
+				}
+				seen.set(id, finder.id);
+				if (!localeFilter(candidate.locale)) continue;
+				kept.push(id);
+				out.push({
+					path: candidate.path,
+					locale: candidate.locale,
+					namespace: candidate.namespace,
+					format: candidate.format,
+					block: candidate.block,
+					readonly: candidate.readonly === true,
+					finder: finder.id
+				});
+			}
+			finderResults.push({
+				id: finder.id,
+				resources: kept
+			});
+		}
+		return out;
+	}
+	function keyFor(resource, stored) {
+		const logical = stored.flatMap((segment) => segment.split("."));
+		if (namespaced) return joinKey(resource.namespace ?? config.namespace.default, logical);
+		return joinKey(void 0, [...resource.namespace ? resource.namespace.split(".") : [], ...logical]);
+	}
+	/** Key path to stored path through the transforms that apply to a resource, last first. */
+	function storedPathOf(ctx) {
+		const active = transforms.filter((transform) => transform.applies?.(ctx) !== false);
+		if (active.length === 0) return (path) => [...path];
+		return (path) => active.reduceRight((current, transform) => transform.toStored(current, ctx), [...path]);
+	}
+	function parseResource(candidate, text) {
+		const format = registry.formatFor(candidate.path, candidate.format);
+		const resource = {
+			id: candidate.block ? `${candidate.path}#${candidate.block.index}` : candidate.path,
+			path: candidate.path,
+			locale: candidate.locale,
+			namespace: candidate.namespace,
+			format: format?.id ?? "unknown",
+			block: candidate.block,
+			readonly: candidate.readonly || !format || !format.edit && !format.serialize,
+			finder: candidate.finder
+		};
+		const content = candidate.block ? text.slice(candidate.block.range.start, candidate.block.range.end) : text;
+		const offset = candidate.block?.range.start ?? 0;
+		const ctx = {
+			path: candidate.path,
+			locale: candidate.locale,
+			namespace: candidate.namespace,
+			indent: config.write.indent
+		};
+		const base = {
+			resource,
+			hash: hashText(content),
+			content,
+			offset,
+			toStored: storedPathOf(ctx)
+		};
+		if (!format) return {
+			...base,
+			tree: {},
+			rawTree: {},
+			ranges: /* @__PURE__ */ new Map(),
+			error: new X18nError("X18N2001", candidate.path)
+		};
+		try {
+			const parsed = format.parse(content, ctx);
+			let tree = parsed.tree;
+			for (const transform of transforms) if (transform.applies?.(ctx) !== false) tree = transform.read(tree, ctx);
+			if (!isMessageTree(tree)) throw new X18nError("X18N2003", candidate.path);
+			return {
+				...base,
+				tree,
+				rawTree: parsed.tree,
+				ranges: parsed.ranges ?? /* @__PURE__ */ new Map(),
+				error: void 0
+			};
+		} catch (error) {
+			const coded = isX18nError(error) ? error : new X18nError("X18N2002", `${candidate.path}: ${error instanceof Error ? error.message : String(error)}`);
+			return {
+				...base,
+				tree: {},
+				rawTree: {},
+				ranges: /* @__PURE__ */ new Map(),
+				error: coded
+			};
+		}
+	}
+	function messagesIn(resource, text) {
+		if (resource.block) return void 0;
+		const format = resource.format === "unknown" ? void 0 : resource.format;
+		const state = parseResource({
+			...resource,
+			format,
+			block: void 0
+		}, text);
+		if (state.error) return void 0;
+		return new Map([...walkLeaves(state.tree)].map((leaf) => [keyFor(state.resource, leaf.path), leaf.value]));
+	}
+	async function loadResources(candidates, reread) {
+		const next = /* @__PURE__ */ new Map();
+		const paths = [...new Set(candidates.map((c) => c.path))];
+		await Promise.all(paths.map(async (path) => {
+			if (reread === "all" || reread.has(path) || !fileTexts.has(path)) {
+				const text = await host.readFile(path);
+				if (text === void 0) fileTexts.delete(path);
+				else fileTexts.set(path, text);
+			}
+		}));
+		namespaced = config.namespace.separator !== "." && candidates.some((c) => c.namespace !== void 0);
+		for (const candidate of candidates) {
+			const text = fileTexts.get(candidate.path);
+			if (text === void 0) continue;
+			const id = candidate.block ? `${candidate.path}#${candidate.block.index}` : candidate.path;
+			const previous = resourceStates.get(id);
+			const content = candidate.block ? text.slice(candidate.block.range.start, candidate.block.range.end) : text;
+			if (previous && previous.hash === hashText(content) && previous.resource.locale === candidate.locale && previous.resource.namespace === candidate.namespace && previous.offset === (candidate.block?.range.start ?? 0)) next.set(id, previous);
+			else next.set(id, parseResource(candidate, text));
+		}
+		resourceStates.clear();
+		for (const [id, state] of next) resourceStates.set(id, state);
+		const found = [...new Set([...resourceStates.values()].map((state) => state.resource.locale))];
+		sourceLocale = config.sourceLocale;
+		if (!found.includes(sourceLocale) && config.origins.sourceLocale === void 0 && found.length > 0) sourceLocale = found.find((code) => code.toLowerCase().startsWith("en")) ?? [...found].sort()[0];
+		locales = [sourceLocale, ...found.filter((code) => code !== sourceLocale).sort()];
+		if (!found.includes(sourceLocale) && found.length === 0) locales = [sourceLocale];
+		resolver = createUsageResolver(config, namespaced, normalizers);
+		resolved = /* @__PURE__ */ new WeakMap();
+		resourceIndex = void 0;
+	}
+	async function scanOne(file) {
+		const usages = [];
+		const scopes = [];
+		const keySlots = [];
+		const hardStrings = [];
+		const calls = config.usage.calls.filter((spec) => ![spec.callee].flat().some((name) => config.usage.ignoreCallees.includes(name)));
+		for (const scanner of registry.scannersFor(file.path)) {
+			const result = await scanner.scan(file, {
+				config,
+				calls
+			});
+			usages.push(...result.usages);
+			scopes.push(...result.scopes ?? []);
+			keySlots.push(...result.keySlots ?? []);
+			hardStrings.push(...result.hardStrings ?? []);
+		}
+		const suppressed = suppressedRanges(file.text);
+		const seen = /* @__PURE__ */ new Set();
+		const kept = usages.filter((usage) => {
+			const id = `${usage.range.start}:${usage.range.end}`;
+			if (seen.has(id)) return false;
+			seen.add(id);
+			return !suppressed.some((range) => usage.range.start >= range.start && usage.range.end <= range.end);
+		});
+		kept.sort((a, b) => a.range.start - b.range.start);
+		return {
+			usages: kept,
+			scopes,
+			keySlots,
+			hardStrings
+		};
+	}
+	async function scanPaths(paths) {
+		const pending = [];
+		const cacheKeys = /* @__PURE__ */ new Map();
+		await Promise.all(paths.map(async (path) => {
+			const text = await host.readFile(path);
+			if (text === void 0) {
+				files.delete(path);
+				return;
+			}
+			const hash = hashText(text);
+			if (files.get(path)?.hash === hash) return;
+			if (host.cache) {
+				const cacheKey = `scan:${scanSignature}:${path}:${hash}`;
+				cacheKeys.set(path, cacheKey);
+				const cached = await host.cache.get(cacheKey);
+				if (cached !== void 0) {
+					files.set(path, {
+						hash,
+						text,
+						result: JSON.parse(cached),
+						error: void 0
+					});
+					return;
+				}
+			}
+			pending.push({
+				path,
+				text,
+				extension: extensionOf(path)
+			});
+		}));
+		const store = (file, result, error) => {
+			files.set(file.path, {
+				hash: hashText(file.text),
+				text: file.text,
+				result: result ?? { usages: [] },
+				error
+			});
+			const cacheKey = cacheKeys.get(file.path);
+			if (result && cacheKey && host.cache) host.cache.set(cacheKey, JSON.stringify(result));
+		};
+		for (let i = 0; i < pending.length; i += scanConcurrency) await Promise.all(pending.slice(i, i + scanConcurrency).map(async (file) => {
+			try {
+				store(file, await scanOne(file));
+			} catch (error) {
+				store(file, void 0, new X18nError("X18N3001", `${file.path}: ${error instanceof Error ? error.message : String(error)}`));
+			}
+		}));
+	}
+	async function scanAll() {
+		if (registry.scanners.length === 0) return;
+		const include = pathMatcher(config.usage.include);
+		const exclude = pathMatcher(config.usage.exclude);
+		usageEligible = (path) => registry.scannersFor(path).length > 0 && include(path) && !exclude(path);
+		await scanPaths((await host.glob(config.usage.include, {
+			ignore: config.usage.exclude,
+			gitignore: true
+		})).filter((path) => registry.scannersFor(path).length > 0));
+	}
+	let index;
+	function buildResourceIndex() {
+		const messages = /* @__PURE__ */ new Map();
+		const keyPaths = /* @__PURE__ */ new Map();
+		const nodes = /* @__PURE__ */ new Map();
+		const parents = /* @__PURE__ */ new Set();
+		for (const state of resourceStates.values()) {
+			const { resource } = state;
+			const fileNodes = nodes.get(resource.path) ?? [];
+			nodes.set(resource.path, fileNodes);
+			const shift = (range) => ({
+				start: range.start + state.offset,
+				end: range.end + state.offset
+			});
+			const visit = (tree, stored) => {
+				for (const [segment, child] of Object.entries(tree)) {
+					const path = [...stored, segment];
+					const key = keyFor(resource, path);
+					const storedPath = state.toStored(path);
+					const raw = state.ranges.get(pathId(storedPath));
+					const range = raw ? {
+						key: shift(raw.key),
+						value: shift(raw.value)
+					} : void 0;
+					if (range) fileNodes.push({
+						key,
+						range,
+						leaf: isMessageLeaf(child),
+						locale: resource.locale,
+						path: resource.path
+					});
+					if (isMessageLeaf(child)) {
+						const byLocale = messages.get(key) ?? /* @__PURE__ */ new Map();
+						messages.set(key, byLocale);
+						const list = byLocale.get(resource.locale) ?? [];
+						byLocale.set(resource.locale, list);
+						list.push({
+							key,
+							locale: resource.locale,
+							value: child,
+							resource: resource.id,
+							storedPath,
+							range
+						});
+						if (!keyPaths.has(key)) {
+							const logical = path.flatMap((s) => s.split("."));
+							keyPaths.set(key, namespaced ? {
+								namespace: resource.namespace ?? config.namespace.default,
+								path: logical
+							} : {
+								namespace: void 0,
+								path: [...resource.namespace ? resource.namespace.split(".") : [], ...logical]
+							});
+						}
+					} else {
+						parents.add(key);
+						visit(child, path);
+					}
+				}
+			};
+			visit(state.tree, []);
+		}
+		for (const { namespace, path } of keyPaths.values()) for (let i = 1; i < path.length; i++) parents.add(joinKey(namespace, path.slice(0, i)));
+		const derived = /* @__PURE__ */ new Map();
+		if (config.usage.derivedKeys.length > 0) for (const key of messages.keys()) {
+			const base = baseOf(key);
+			if (base) {
+				const list = derived.get(base) ?? [];
+				derived.set(base, list);
+				list.push(key);
+			}
+		}
+		return {
+			messages,
+			keyPaths,
+			nodes,
+			parents,
+			derived
+		};
+	}
+	function buildIndex() {
+		resourceIndex ??= buildResourceIndex();
+		const usages = [];
+		for (const [path, state] of [...files].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+			let list = resolved.get(state);
+			if (!list) {
+				list = state.result.usages.map((candidate) => resolver.resolve(candidate, state.result.scopes ?? [], path, "scanner"));
+				resolved.set(state, list);
+			}
+			usages.push(...list);
+		}
+		const usagesByKey = /* @__PURE__ */ new Map();
+		const prefixUsages = [];
+		for (const usage of usages) {
+			if (usage.key === void 0) continue;
+			if (usage.dynamic === "prefix") {
+				prefixUsages.push(usage);
+				continue;
+			}
+			const list = usagesByKey.get(usage.key) ?? [];
+			usagesByKey.set(usage.key, list);
+			list.push(usage);
+		}
+		return {
+			revision,
+			...resourceIndex,
+			usages,
+			usagesByKey,
+			prefixUsages
+		};
+	}
+	function idx() {
+		if (!index || index.revision !== revision) index = buildIndex();
+		return index;
+	}
+	function message(key, locale) {
+		return idx().messages.get(key)?.get(locale)?.[0];
+	}
+	const history = createHistory({
+		providers: config.history === false ? [] : [...config.history.providers, ...registry.histories],
+		context: () => ({
+			host,
+			config,
+			resources: [...resourceStates.values()].map((state) => state.resource),
+			messagesIn
+		}),
+		current: (key, locale) => message(key, locale)?.value,
+		onLoad() {
+			revision++;
+			emit({
+				revision,
+				paths: [],
+				keys: []
+			});
+		},
+		logger: host.logger
+	});
+	function usageMatches(query = {}) {
+		const { usages, usagesByKey, prefixUsages } = idx();
+		const inPath = (usage) => query.path === void 0 || usage.path === query.path;
+		if (query.key !== void 0) {
+			const key = query.key;
+			const base = baseOf(key);
+			return [...[...usagesByKey.get(key) ?? [], ...base ? usagesByKey.get(base) ?? [] : []].filter(inPath).map((usage) => ({
+				usage,
+				possible: false
+			})), ...prefixUsages.filter((usage) => inPath(usage) && prefixMatches(usage, key)).map((usage) => ({
+				usage,
+				possible: true
+			}))];
+		}
+		if (query.prefix !== void 0) {
+			const prefix = query.prefix;
+			return [...usages.filter((usage) => inPath(usage) && usage.dynamic === false && usage.key !== void 0 && isKeyUnder(usage.key, prefix)).map((usage) => ({
+				usage,
+				possible: false
+			})), ...prefixUsages.filter((usage) => inPath(usage) && usage.key !== void 0 && (usage.key.startsWith(prefix) || prefix.startsWith(usage.key))).map((usage) => ({
+				usage,
+				possible: true
+			}))];
+		}
+		return usages.filter(inPath).map((usage) => ({
+			usage,
+			possible: usage.dynamic !== false
+		}));
+	}
+	const analyzer = createAnalyzer({
+		config,
+		registry,
+		state: () => ({
+			revision,
+			sourceLocale,
+			locales,
+			resources: [...resourceStates.values()],
+			resourceErrors: [...resourceStates.values()].flatMap((s) => s.error ? [{
+				error: s.error,
+				path: s.resource.path
+			}] : []),
+			scanErrors: [...files].flatMap(([path, s]) => s.error ? [{
+				error: s.error,
+				path
+			}] : []),
+			discoveryErrors,
+			messages: idx().messages,
+			parents: idx().parents,
+			usages: idx().usages,
+			usagesByKey: idx().usagesByKey,
+			prefixUsages: idx().prefixUsages,
+			derived: idx().derived,
+			files,
+			history: history.get
+		}),
+		baseOf,
+		localeInfo,
+		text: (path) => fileTexts.get(path) ?? files.get(path)?.text
+	});
+	function keys(query = {}) {
+		const { messages, keyPaths } = idx();
+		const match = query.glob ? keyMatcher([query.glob]) : void 0;
+		let list = [...messages.keys()];
+		if (match) list = list.filter((key) => match(key));
+		if (query.namespace !== void 0) list = list.filter((key) => keyPaths.get(key)?.namespace === query.namespace);
+		if (query.missing !== void 0) {
+			const locale = query.missing;
+			list = list.filter((key) => {
+				const value = message(key, locale)?.value;
+				return message(key, sourceLocale) !== void 0 && (value === void 0 || value === "");
+			});
+		}
+		if (query.unused) {
+			const unused = new Set(analyzer.analyze().unused);
+			list = list.filter((key) => unused.has(key));
+		}
+		return list.sort();
+	}
+	function get(key) {
+		const { messages, keyPaths } = idx();
+		const byLocale = messages.get(key);
+		if (!byLocale) return void 0;
+		const id = keyPaths.get(key);
+		const list = locales.flatMap((locale) => byLocale.get(locale)?.slice(0, 1) ?? []);
+		return {
+			key,
+			namespace: id.namespace,
+			path: id.path,
+			messages: list,
+			missing: locales.filter((locale) => !byLocale.has(locale)),
+			usages: usageMatches({ key }),
+			diagnostics: analyzer.analyze().diagnostics.filter((d) => d.key === key)
+		};
+	}
+	function keyAt(path, offset) {
+		const fileNodes = idx().nodes.get(path);
+		if (fileNodes) {
+			let best;
+			for (const node of fileNodes) if ((rangeContains(node.range.key, offset) || node.leaf && rangeContains(node.range.value, offset)) && (!best || node.range.key.start > best.range.key.start)) best = node;
+			if (best) return best.leaf ? {
+				type: "key",
+				key: best.key,
+				range: best.range.key,
+				source: "resource"
+			} : {
+				type: "subtree",
+				key: best.key,
+				range: best.range.key,
+				source: "resource"
+			};
+		}
+		if (files.get(path)) {
+			const usage = idx().usages.find((u) => u.path === path && u.key !== void 0 && rangeContains(u.range, offset));
+			if (usage?.key !== void 0) return {
+				type: "key",
+				key: usage.key,
+				range: usage.range,
+				source: "usage",
+				usage
+			};
+		}
+	}
+	function explain() {
+		const resources = [...resourceStates.values()];
+		return {
+			name: config.name,
+			root: host.root,
+			presets: setup.presets,
+			plugins: registry.plugins.map((plugin) => plugin.name),
+			skipped: setup.skipped,
+			finders: finderResults,
+			duplicates,
+			formats: registry.formats.map((format) => ({
+				id: format.id,
+				extensions: format.extensions,
+				resources: resources.filter((state) => state.resource.format === format.id).length
+			})),
+			scanners: registry.scanners.map((scanner) => ({
+				id: scanner.id,
+				extensions: scanner.extensions,
+				files: [...files.keys()].filter((path) => registry.scannersFor(path).includes(scanner)).length
+			})),
+			conflicts: registry.conflicts,
+			errors: [
+				...discoveryErrors,
+				...resources.flatMap((state) => state.error ? [{
+					error: state.error,
+					path: state.resource.path
+				}] : []),
+				...[...files].flatMap(([path, state]) => state.error ? [{
+					error: state.error,
+					path
+				}] : [])
+			].map(({ error, path }) => ({
+				...error.toJSON(),
+				path
+			})),
+			config
+		};
+	}
+	function emit(change) {
+		for (const listener of listeners) listener(change);
+	}
+	function touchedKeys(paths, before) {
+		const out = /* @__PURE__ */ new Set();
+		const collect = (from) => {
+			if (!from) return;
+			for (const path of paths) for (const node of from.nodes.get(path) ?? []) out.add(node.key);
+			for (const usage of from.usages) if (usage.key !== void 0 && paths.has(usage.path)) out.add(usage.key);
+		};
+		collect(before);
+		collect(idx());
+		return [...out];
+	}
+	let current = Promise.resolve();
+	async function update(events) {
+		const run = current.then(async () => {
+			if (events.length === 0) return void 0;
+			const before = idx();
+			const paths = new Set(events.map((event) => event.path));
+			const resourcePaths = new Set([...resourceStates.values()].map((state) => state.resource.path));
+			const maybeResource = (path) => !resourcePaths.has(path) && registry.formatFor(path) !== void 0 && !usageEligible(path);
+			const structural = events.some((event) => event.type !== "change" || maybeResource(event.path));
+			if (structural || [...paths].some((path) => resourcePaths.has(path))) await loadResources(structural ? await discover() : [...resourceStates.values()].map((state) => ({
+				...state.resource,
+				format: state.resource.format === "unknown" ? void 0 : state.resource.format
+			})), paths);
+			const scanTargets = [...paths].filter((path) => usageEligible(path) || files.has(path));
+			for (const event of events) if (event.type === "delete") files.delete(event.path);
+			await scanPaths(scanTargets.filter((path) => events.some((event) => event.path === path && event.type !== "delete")));
+			revision++;
+			const change = {
+				revision,
+				paths: [...paths],
+				keys: touchedKeys(paths, before)
+			};
+			emit(change);
+			return change;
+		});
+		current = run.then(() => void 0, () => void 0);
+		return run;
+	}
+	const planner = createPlanner({
+		host,
+		config,
+		registry,
+		state: () => ({
+			revision,
+			sourceLocale,
+			locales,
+			namespaced,
+			resources: [...resourceStates.values()],
+			fileTexts
+		}),
+		message: (key, locale) => message(key, locale),
+		messages: (key) => idx().messages.get(key),
+		allKeys: () => [...idx().messages.keys()],
+		parents: () => idx().parents,
+		usageMatches,
+		text: (path) => fileTexts.get(path) ?? files.get(path)?.text,
+		baseOf,
+		toStored: (target, path) => storedPathOf(target)(path),
+		resolveNew(locale, namespace) {
+			const ctx = {
+				host,
+				config,
+				extensions: [...new Set(registry.formats.flatMap((format) => format.extensions))]
+			};
+			for (const finder of registry.finders) {
+				const path = finder.resolveNew?.({
+					locale,
+					namespace
+				}, ctx);
+				if (path) return path;
+			}
+		},
+		update
+	});
+	const ready = (async () => {
+		await loadResources(await discover(), "all");
+		await scanAll();
+		revision++;
+	})();
+	const project = {
+		get name() {
+			return config.name;
+		},
+		config,
+		ready,
+		get revision() {
+			return revision;
+		},
+		get locales() {
+			return locales;
+		},
+		get sourceLocale() {
+			return sourceLocale;
+		},
+		get resources() {
+			return [...resourceStates.values()].map((state) => state.resource);
+		},
+		get namespaced() {
+			return namespaced;
+		},
+		reporters: registry.reporters,
+		placeholderSyntaxes: registry.placeholders,
+		extractTemplates: [...(config.extract.templates ?? []).map((template) => typeof template === "string" ? { template } : template), ...registry.extractors.flatMap((extractor) => extractor.templates)],
+		keys,
+		get,
+		message,
+		parseKey(input) {
+			const separator = config.namespace.separator;
+			if (!namespaced) return input;
+			if (input.indexOf(":") > 0) return input;
+			const custom = separator !== ":" ? input.indexOf(separator) : -1;
+			if (custom > 0) return `${input.slice(0, custom)}:${input.slice(custom + separator.length)}`;
+			return config.namespace.default ? `${config.namespace.default}:${input}` : input;
+		},
+		usages: usageMatches,
+		keyAt,
+		nodes: (path) => idx().nodes.get(path) ?? [],
+		locations(key) {
+			const order = new Map(locales.map((locale, i) => [locale, i]));
+			const all = [...idx().nodes.values()].flat();
+			let found = all.filter((node) => node.key === key);
+			if (found.length === 0) {
+				const derived = new Set(idx().derived.get(key) ?? []);
+				found = all.filter((node) => derived.has(node.key));
+			}
+			return found.sort((a, b) => (order.get(a.locale) ?? 0) - (order.get(b.locale) ?? 0));
+		},
+		lookup(key, locale) {
+			const exact = message(key, locale);
+			if (exact) return exact;
+			const derived = [...idx().derived.get(key) ?? []].sort();
+			const other = derived.find((k) => /[._-]other$/.test(k)) ?? derived[0];
+			return other === void 0 ? void 0 : message(other, locale);
+		},
+		keySlots: (path) => files.get(path)?.result.keySlots ?? [],
+		hardStrings: (path) => [...files].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).filter(([p]) => path === void 0 || p === path).flatMap(([p, state]) => (state.result.hardStrings ?? []).map((h) => ({
+			...h,
+			path: p
+		}))),
+		analyze: () => analyzer.analyze(),
+		async loadHistory(historyOptions = {}) {
+			await ready;
+			await history.load(historyOptions);
+		},
+		history: history.get,
+		valueAt: history.valueAt,
+		prompt: (kind, locale, promptOptions = {}) => buildPrompt(project, kind, locale, promptOptions, {
+			config,
+			hooks: registry.plugins.flatMap((plugin) => plugin.translatePrompt ? [plugin.translatePrompt] : [])
+		}),
+		explain,
+		localeInfo,
+		text: (path) => fileTexts.get(path) ?? files.get(path)?.text,
+		owns: (path) => fileTexts.has(path) || files.has(path) || usageEligible(path),
+		plan: (ops) => planner.plan(ops),
+		apply: (plan, applyOptions) => planner.apply(plan, applyOptions?.answers ?? {}),
+		update,
+		watch() {
+			if (watcher || !host.watch) return;
+			watcher = host.watch(["**/*"], (events) => {
+				update(events);
+			});
+		},
+		onChange(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		dispose() {
+			watcher?.dispose();
+			history.dispose();
+			listeners.clear();
+		}
+	};
+	return project;
+}
+//#endregion
+//#region src/resolve.ts
+const defaultExclude = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/coverage/**",
+	"**/.nuxt/**",
+	"**/.output/**",
+	"**/.next/**",
+	"**/.svelte-kit/**",
+	"**/*.d.ts",
+	"**/*.min.js"
+];
+function defaultDraft() {
+	return {
+		sourceLocale: "en",
+		locales: void 0,
+		ignoreLocales: [],
+		resources: [],
+		formats: {},
+		keyStyle: "auto",
+		namespace: {
+			separator: ".",
+			default: void 0,
+			fromPath: "dot"
+		},
+		usage: {
+			include: ["**/*"],
+			exclude: defaultExclude,
+			calls: [],
+			regex: [],
+			ignoreCallees: [],
+			keysInUse: [],
+			derivedKeys: []
+		},
+		write: {
+			sort: false,
+			indent: void 0,
+			keepFilled: false
+		},
+		extract: {},
+		checks: {},
+		strict: false,
+		ignoreKeys: [],
+		glossary: [],
+		history: { providers: [] },
+		pluginConfigs: {}
+	};
+}
+function serializablePart(config) {
+	const { presets, plugins, pluginConfigs, history, ...rest } = config;
+	if (typeof history !== "object") return {
+		...rest,
+		history
+	};
+	const { providers, ...options } = history;
+	return {
+		...rest,
+		history: options
+	};
+}
+/** Applies a user config layer: scalars replace, lists of rules append. */
+function applyLayer(draft, layer, origin, origins) {
+	const mark = (key) => {
+		origins[key] = origin;
+	};
+	if (layer.sourceLocale !== void 0) {
+		draft.sourceLocale = layer.sourceLocale;
+		mark("sourceLocale");
+	}
+	if (layer.locales !== void 0) {
+		draft.locales = layer.locales;
+		mark("locales");
+	}
+	if (layer.ignoreLocales !== void 0) {
+		draft.ignoreLocales = [...draft.ignoreLocales, ...layer.ignoreLocales];
+		mark("ignoreLocales");
+	}
+	if (layer.resources !== void 0) {
+		draft.resources = layer.resources;
+		mark("resources");
+	}
+	if (layer.formats !== void 0) {
+		draft.formats = {
+			...draft.formats,
+			...layer.formats
+		};
+		mark("formats");
+	}
+	if (layer.keyStyle !== void 0) {
+		draft.keyStyle = layer.keyStyle;
+		mark("keyStyle");
+	}
+	if (layer.namespace !== void 0) {
+		draft.namespace = {
+			separator: layer.namespace.separator ?? draft.namespace.separator,
+			default: layer.namespace.default ?? draft.namespace.default,
+			fromPath: layer.namespace.fromPath ?? draft.namespace.fromPath
+		};
+		mark("namespace");
+	}
+	const usage = layer.usage;
+	if (usage !== void 0) {
+		draft.usage = {
+			include: usage.include ?? draft.usage.include,
+			exclude: [...draft.usage.exclude, ...usage.exclude ?? []],
+			calls: [...draft.usage.calls, ...usage.calls ?? []],
+			regex: [...draft.usage.regex, ...usage.regex ?? []],
+			ignoreCallees: [...draft.usage.ignoreCallees, ...usage.ignoreCallees ?? []],
+			keysInUse: [...draft.usage.keysInUse, ...usage.keysInUse ?? []],
+			derivedKeys: [...draft.usage.derivedKeys, ...usage.derivedKeys ?? []]
+		};
+		mark("usage");
+	}
+	if (layer.write !== void 0) {
+		draft.write = {
+			sort: layer.write.sort ?? draft.write.sort,
+			indent: layer.write.indent ?? draft.write.indent,
+			keepFilled: layer.write.keepFilled ?? draft.write.keepFilled
+		};
+		mark("write");
+	}
+	if (layer.extract !== void 0) {
+		draft.extract = {
+			...draft.extract,
+			...layer.extract,
+			templates: [...draft.extract.templates ?? [], ...layer.extract.templates ?? []]
+		};
+		mark("extract");
+	}
+	if (layer.checks !== void 0) {
+		draft.checks = {
+			...draft.checks,
+			...layer.checks
+		};
+		mark("checks");
+	}
+	if (layer.strict !== void 0) {
+		draft.strict = layer.strict;
+		mark("strict");
+	}
+	if (layer.ignoreKeys !== void 0) {
+		draft.ignoreKeys = [...draft.ignoreKeys, ...layer.ignoreKeys];
+		mark("ignoreKeys");
+	}
+	if (layer.glossary !== void 0) {
+		draft.glossary = [...draft.glossary, ...layer.glossary];
+		mark("glossary");
+	}
+	if (layer.history !== void 0) {
+		const previous = draft.history || { providers: [] };
+		draft.history = layer.history === false ? false : layer.history === true ? previous : {
+			...previous,
+			...layer.history,
+			providers: [...previous.providers, ...layer.history.providers ?? []]
+		};
+		mark("history");
+	}
+	if (layer.pluginConfigs !== void 0) {
+		draft.pluginConfigs = {
+			...draft.pluginConfigs,
+			...layer.pluginConfigs
+		};
+		mark("pluginConfigs");
+	}
+}
+async function createDetectContext(host, readers, roots) {
+	const dependencies = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	for (const root of ["", ...roots]) for (const reader of readers) {
+		const path = root ? `${root.replace(/\/$/, "")}/${reader.file}` : reader.file;
+		if (seen.has(path)) continue;
+		seen.add(path);
+		const text = await host.readFile(path);
+		if (text === void 0) continue;
+		try {
+			for (const name of reader.read(text)) dependencies.add(name);
+		} catch {
+			host.logger?.warn(`Could not read manifest ${path}`);
+		}
+	}
+	return {
+		host,
+		dependencies,
+		hasDependency: (name) => dependencies.has(name),
+		hasAnyDependency: (names) => names.some((name) => dependencies.has(name)),
+		fileExists: async (pattern) => (await host.glob([pattern], { gitignore: true })).length > 0
+	};
+}
+function validateLayers(layers) {
+	for (const layer of layers) {
+		if (!layer) continue;
+		const result = validate(ConfigSchema, serializablePart(layer));
+		if (!result.success) throw new X18nError("X18N0001", result.issues.map((issue) => `${issue.path || "(root)"}: ${issue.message}`).join("; "));
+	}
+}
+function createLoader(options) {
+	return async (option) => {
+		if (option === false || option === void 0) return void 0;
+		if (typeof option === "object" && !Array.isArray(option)) return option;
+		const [specifier, pluginOptions] = typeof option === "string" ? [option, void 0] : [option[0], option[1]];
+		const factory = options.builtins.presets[specifier];
+		if (factory) return factory(pluginOptions);
+		if (!options.loadPlugin) throw new X18nError("X18N1003", specifier);
+		return options.loadPlugin(specifier, pluginOptions);
+	};
+}
+async function loadAll(load, list) {
+	const out = [];
+	for (const option of list) {
+		const loaded = await load(option);
+		if (loaded) out.push(loaded);
+	}
+	return out;
+}
+/** Expands presets depth-first: listed presets always apply, others only when detected; an exclusive one stops the rest. */
+async function expandPresets(presets, userPlugins, listed, detectCtx) {
+	const explanations = [];
+	const plugins = [];
+	const flatten = async (item, force) => {
+		if (!isPreset(item)) {
+			if (!plugins.some((plugin) => plugin.name === item.name)) plugins.push(item);
+			return false;
+		}
+		const applies = force || (item.detect ? await item.detect(detectCtx) : false);
+		explanations.push({
+			name: item.name,
+			reason: applies ? force ? "listed" : "detected" : "not-detected"
+		});
+		if (!applies) return false;
+		for (const child of item.plugins) await flatten(child, false);
+		return item.exclusive === true;
+	};
+	let stopped = false;
+	for (const preset of presets) if (stopped) explanations.push({
+		name: preset.name,
+		reason: "after-exclusive"
+	});
+	else stopped = await flatten(preset, listed);
+	for (const plugin of userPlugins) await flatten(plugin, true);
+	return {
+		plugins,
+		explanations
+	};
+}
+async function runConfigHooks(plugins, draft, ctx, origins) {
+	for (const plugin of plugins) {
+		if (!plugin.config) continue;
+		const snapshot = Object.fromEntries(Object.entries(draft).map(([key, value]) => [key, JSON.stringify(value)]));
+		await plugin.config(draft, ctx);
+		for (const [key, value] of Object.entries(draft)) if (snapshot[key] !== JSON.stringify(value)) origins[key] = `plugin:${plugin.name}`;
+	}
+}
+async function resolveConfig(options) {
+	const { host, builtins } = options;
+	const user = options.config;
+	validateLayers([options.parent, user]);
+	const load = createLoader(options);
+	const userPlugins = await loadAll(load, [...options.parent?.plugins ?? [], ...user.plugins ?? []]);
+	const presetOption = user.presets ?? options.parent?.presets ?? "auto";
+	const auto = presetOption === "auto";
+	const presets = auto ? Object.values(builtins.presets).map((factory) => factory()) : (await loadAll(load, presetOption)).map((item) => isPreset(item) ? item : {
+		name: item.name,
+		plugins: [item]
+	});
+	const detectCtx = await createDetectContext(host, [...builtins.plugins, ...userPlugins].flatMap((item) => isPreset(item) ? [] : item.manifests ?? []), options.manifestRoots ?? []);
+	const expanded = await expandPresets(presets, userPlugins, !auto, detectCtx);
+	const skipped = [];
+	const finalPlugins = [...builtins.plugins, ...expanded.plugins].filter((plugin) => {
+		const skip = options.runtime === "browser" && plugin.runtime === "node";
+		if (skip) skipped.push({
+			name: plugin.name,
+			reason: "node only"
+		});
+		return !skip;
+	});
+	const draft = defaultDraft();
+	const origins = {};
+	await runConfigHooks(finalPlugins, draft, {
+		host,
+		user: serializablePart(user)
+	}, origins);
+	if (options.parent) applyLayer(draft, options.parent, "parent", origins);
+	applyLayer(draft, user, "user", origins);
+	const config = Object.freeze({
+		...draft,
+		name: user.name ?? options.name ?? "default",
+		usage: {
+			...draft.usage,
+			derivedKeys: [...draft.usage.derivedKeys, ...finalPlugins.flatMap((plugin) => plugin.derivedKeys ?? [])]
+		},
+		origins
+	});
+	for (const plugin of finalPlugins) plugin.configResolved?.(config);
+	return {
+		config,
+		registry: createRegistry(finalPlugins, config),
+		presets: expanded.explanations,
+		skipped
+	};
+}
+//#endregion
+export { ConfigSchema, PluginFileSchema, X18nError, applyMessageOps, applyTextEdits, buildTree, contractVersion, createLineIndex, createMemoryHost, createOverlayHost, createPlaceholderComparer, createProject, createRegistry, defineConfig, definePlugin, definePreset, diffText, envelope, errorCodes, extensionOf, globToRegExp, hashText, isJsonObject, isKeyUnder, isMessageLeaf, isMessageTree, isPreset, isX18nError, joinKey, keyMatcher, localeSpellingKey, parseLocaleInfo, parseMessageBatch, pathId, pathMatcher, placeholderProblems, rangeContains, renderPrompt, replaceKeyPrefix, resolveConfig, sortTree, splitKey, toWireDiagnostic, toWireRange, validate, walkLeaves };