@dialexjs/cli 0.2.3 → 0.5.0

package/dist/{project-BnG6V2I0.mjs → project-BJYmnKiU.mjs}

@@ -1,122 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
+import { renderDts, resolveDialexConfig } from "dialexjs/scanner";
 import fg from "fast-glob";
-import chokidar from "chokidar";
-import { generateDts, resolveI18nConfig } from "dialexjs/scanner";
 import pc from "picocolors";
-import { generateCode, parseExpression, parseModule, writeFile } from "magicast";
 import { pathToFileURL } from "node:url";
-import { argumentSignature, findPlurals, isIcuStructured, parseMessage } from "dialexjs/icu";
-//#region src/utils/logger.ts
-const logger = {
-	info: (msg) => console.log(pc.blue("ℹ ") + msg),
-	success: (msg) => console.log(pc.green("✔ ") + pc.bold(msg)),
-	warn: (msg) => console.warn(pc.yellow("⚠ ") + msg),
-	error: (msg) => console.error(pc.red("✖ ") + pc.bold(msg)),
-	log: (msg) => console.log(msg)
-};
-//#endregion
-//#region src/commands/generate.ts
-function generateDictionaries(root, options = {}) {
-	const inlineConfig = options.config ? { configFile: options.config } : {};
-	const config = resolveI18nConfig(root, inlineConfig);
-	const include = config.include || "**/*.content.ts";
-	const files = fg.sync(include, {
-		cwd: root,
-		absolute: true,
-		ignore: [
-			"**/node_modules/**",
-			"**/dist/**",
-			"**/.next/**"
-		]
-	});
-	const srcDir = fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root;
-	const targetOutput = options.output ? path.resolve(root, options.output) : path.join(srcDir, "dialex.generated.ts");
-	const targetDir = path.dirname(targetOutput);
-	generateDts(root, files, config.locales);
-	const dtsPath = path.join(srcDir, "dialex-env.d.ts");
-	const importLines = [];
-	const dictIdentifiers = [];
-	files.forEach((file, idx) => {
-		let rel = path.relative(targetDir, file).replace(/\\/g, "/");
-		rel = rel.replace(/\.ts$/, ".js");
-		if (!rel.startsWith(".")) rel = "./" + rel;
-		const id = `dict_${idx}`;
-		importLines.push(`import ${id} from "${rel}";`);
-		dictIdentifiers.push(id);
-	});
-	const dictList = dictIdentifiers.length <= 1 ? `[${dictIdentifiers.join(", ")}]` : `[\n  ${dictIdentifiers.join(",\n  ")}\n]`;
-	const content = `// Auto-generated by dialex CLI. Do not edit directly.
-/* eslint-disable */
-// @ts-nocheck
-${importLines.join("\n")}
-
-export const dictionaries = ${dictList};
-
-export const dictionaryMap = {
-${dictIdentifiers.map((id) => `  [${id}.name]: ${id}.dictionary,`).join("\n")}
-};
-
-export default dictionaries;
-`;
-	fs.mkdirSync(targetDir, { recursive: true });
-	if ((fs.existsSync(targetOutput) ? fs.readFileSync(targetOutput, "utf-8") : "") !== content) fs.writeFileSync(targetOutput, content, "utf-8");
-	return {
-		files,
-		outputPath: targetOutput,
-		dtsPath
-	};
-}
-async function runGenerate(options = {}) {
-	const root = options.cwd || process.cwd();
-	const quiet = options.json === true;
-	const doGenerate = () => {
-		try {
-			const { files, outputPath, dtsPath } = generateDictionaries(root, options);
-			if (quiet) console.log(JSON.stringify({
-				success: true,
-				files: files.map((f) => path.relative(root, f)),
-				outputPath: path.relative(root, outputPath),
-				dtsPath: path.relative(root, dtsPath)
-			}, null, 2));
-			else {
-				logger.success(`Generated dictionaries for ${files.length} file${files.length === 1 ? "" : "s"}:`);
-				logger.info(`→ ${path.relative(root, outputPath)}`);
-				logger.info(`→ ${path.relative(root, dtsPath)}`);
-			}
-			return true;
-		} catch (err) {
-			if (quiet) console.log(JSON.stringify({
-				success: false,
-				error: err.message || String(err)
-			}, null, 2));
-			else logger.error(`Generation failed: ${err.message || String(err)}`);
-			return false;
-		}
-	};
-	if (!doGenerate() && !options.watch) process.exit(1);
-	if (options.watch) {
-		logger.info("Watching for dictionary changes (-w, --watch)...");
-		const inlineConfig = options.config ? { configFile: options.config } : {};
-		const pattern = resolveI18nConfig(root, inlineConfig).include || "**/*.content.ts";
-		chokidar.watch(pattern, {
-			cwd: root,
-			ignoreInitial: true,
-			ignored: [
-				"**/node_modules/**",
-				"**/dist/**",
-				"**/.next/**"
-			]
-		}).on("all", (event, filePath) => {
-			logger.info(`[${event}] ${filePath} changed, regenerating...`);
-			doGenerate();
-		});
-	}
-}
-//#endregion
+import { generateCode, parseExpression, parseModule, writeFile } from "magicast";
+import { argumentSignature, findPlurals, getArguments, isIcuStructured, parseMessage } from "dialexjs/icu";
+import { createHash } from "node:crypto";
+import chokidar from "chokidar";
+import { DEFAULT_CONFIG } from "dialexjs";
 //#region src/utils/dictionary-edit.ts
 const TODO_PREFIX = "[TODO] ";
-const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+const IDENTIFIER$1 = /^[A-Za-z_$][\w$]*$/;
 function unwrap(node) {
 	while (node && (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "ParenthesizedExpression")) node = node.expression;
 	return node;
@@ -171,7 +66,7 @@ function locateLocalesObject(declaration) {
 }
 /** Quotes a property key only when it is not a valid identifier. */
 function keyCode(key) {
-	return IDENTIFIER.test(key) ? key : JSON.stringify(key);
+	return IDENTIFIER$1.test(key) ? key : JSON.stringify(key);
 }
 /** Builds a detached `key: <value>` property node from source text. */
 function makeProp(key, valueCode) {
@@ -459,15 +354,84 @@ function checkIcu(dictionary, strings, defaultLocale) {
 	return findings;
 }
 //#endregion
+//#region src/utils/lockfile.ts
+const LOCK_FILE = "dialex.lock.json";
+const emptyLock = (sourceLocale) => ({
+	version: 1,
+	...sourceLocale ? { sourceLocale } : {},
+	locales: {}
+});
+const lockPath = (root) => path.join(root, LOCK_FILE);
+/** A short, stable fingerprint of a source string. */
+function hashSource(text) {
+	return createHash("sha1").update(text).digest("hex").slice(0, 8);
+}
+/** The lock file, or `undefined` when there is none (or it cannot be read). */
+function readLock(root) {
+	try {
+		const data = JSON.parse(fs.readFileSync(lockPath(root), "utf-8"));
+		if (data?.version !== 1 || typeof data.locales !== "object" || data.locales === null) return;
+		return {
+			version: 1,
+			...typeof data.sourceLocale === "string" ? { sourceLocale: data.sourceLocale } : {},
+			locales: data.locales
+		};
+	} catch {
+		return;
+	}
+}
+/** Writes the lock with sorted keys, so it produces small, stable diffs. */
+function writeLock(root, lock) {
+	const sorted = {
+		version: 1,
+		...lock.sourceLocale ? { sourceLocale: lock.sourceLocale } : {},
+		locales: Object.fromEntries(Object.keys(lock.locales).sort().map((locale) => [locale, Object.fromEntries(Object.entries(lock.locales[locale]).sort(([a], [b]) => a.localeCompare(b)))]))
+	};
+	fs.writeFileSync(lockPath(root), JSON.stringify(sorted, null, 2) + "\n", "utf-8");
+}
+/** Notes that `key` in `locale` was written from this source text. */
+function record(lock, locale, key, sourceText) {
+	(lock.locales[locale] ??= {})[key] = hashSource(sourceText);
+}
+/**
+* True when `key` was recorded for `locale` from different source text than `sourceText`. A key
+* with no record is not stale.
+*/
+function isStale(lock, locale, key, sourceText) {
+	const recorded = lock.locales[locale]?.[key];
+	return recorded !== void 0 && recorded !== hashSource(sourceText);
+}
+/**
+* The lock to use for a run translating from `sourceLocale`. A lock written from another source
+* locale says nothing about this one, so it is replaced by a fresh one.
+*/
+function lockFor(root, sourceLocale) {
+	const existing = readLock(root);
+	if (!existing) return {
+		lock: emptyLock(sourceLocale),
+		replaced: false
+	};
+	if (existing.sourceLocale && existing.sourceLocale !== sourceLocale) return {
+		lock: emptyLock(sourceLocale),
+		replaced: true
+	};
+	existing.sourceLocale = sourceLocale;
+	return {
+		lock: existing,
+		replaced: false
+	};
+}
+//#endregion
 //#region src/analysis.ts
-const DICTIONARY_IGNORE = [
+const DICTIONARY_IGNORE$1 = [
 	"**/node_modules/**",
 	"**/dist/**",
-	"**/.next/**"
+	"**/.next/**",
+	"**/dialex.locales/**"
 ];
 const DEFAULT_SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte,astro,mdx}";
 const SOURCE_IGNORE = [
-	...DICTIONARY_IGNORE,
+	...DICTIONARY_IGNORE$1,
 	"**/.nuxt/**",
 	"**/.output/**",
 	"**/.svelte-kit/**",
@@ -479,8 +443,8 @@ const SOURCE_IGNORE = [
 	"**/dialex.config.*",
 	"**/i18n.config.*"
 ];
-/** `getDictionary("x")`, `useDictionary("x")`, `@I18nDictionary("x")` */
-const DICTIONARY_CALL = /\b(?:getDictionary|useDictionary|I18nDictionary)\(\s*(["'`])([^"'`$\n]+)\1/dg;
+/** `getDictionary("x")`, `useDictionary("x")`, `@DialexDictionary("x")` */
+const DICTIONARY_CALL = /\b(?:getDictionary|useDictionary|DialexDictionary)\(\s*(["'`])([^"'`$\n]+)\1/dg;
 /** `t("dictionary.path.to.key")` */
 const T_CALL = /(?<![\w$.])t\(\s*(["'`])([\w-]+(?:\.[\w-]+)+)\1/dg;
 /** Finds `getDictionary("x")`-style and `t("x.y.z")` references in source text. */
@@ -622,10 +586,11 @@ async function analyzeProject(options) {
 	const files = fg.sync(include, {
 		cwd: root,
 		absolute: true,
-		ignore: [...DICTIONARY_IGNORE, ...extraIgnore]
+		ignore: [...DICTIONARY_IGNORE$1, ...extraIgnore]
 	});
 	const issues = [];
 	const dictionaries = [];
+	const lock = options.lock === false ? void 0 : readLock(root);
 	for (const file of files) {
 		const loaded = await loadDictionaryData(file, options.runtime === true);
 		if (!loaded.ok) {
@@ -691,6 +656,26 @@ async function analyzeProject(options) {
 				});
 			}
 		}
+		const sourceLeaves = lock?.sourceLocale ? data.leaves.get(lock.sourceLocale) : void 0;
+		if (lock && sourceLeaves) for (const locale of data.locales) {
+			if (locale === lock.sourceLocale) continue;
+			for (const [leafPath, leaf] of data.leaves.get(locale)) {
+				if (leaf.kind !== "string" || leaf.value === void 0) continue;
+				if (leaf.value.startsWith("[TODO] ")) continue;
+				const source = sourceLeaves.get(leafPath);
+				if (source?.kind !== "string" || source.value === void 0) continue;
+				if (!isStale(lock, locale, `${data.name}.${leafPath}`, source.value)) continue;
+				add({
+					level: "warning",
+					code: "stale-translation",
+					message: `Locale "${locale}" key "${leafPath}" is out of date: the "${lock.sourceLocale}" text changed after it was translated`,
+					range: at(locale, leafPath.split(".")),
+					locale,
+					path: leafPath.split("."),
+					sourceLocale: lock.sourceLocale
+				});
+			}
+		}
 		for (const finding of checkIcu(data.name, strings, defaultLocale)) {
 			const keyPath = finding.key.slice(data.name.length + 1).split(".");
 			add({
@@ -801,6 +786,186 @@ function relativeFile(root, file) {
 	return path.relative(root, file);
 }
 //#endregion
+//#region src/utils/logger.ts
+const logger = {
+	info: (msg) => console.log(pc.blue("ℹ ") + msg),
+	success: (msg) => console.log(pc.green("✔ ") + pc.bold(msg)),
+	warn: (msg) => console.warn(pc.yellow("⚠ ") + msg),
+	error: (msg) => console.error(pc.red("✖ ") + pc.bold(msg)),
+	log: (msg) => console.log(msg)
+};
+//#endregion
+//#region src/utils/message-arguments.ts
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+/**
+* The TypeScript type of one ICU argument. A name can appear more than once (in a `plural` and as
+* a plain `{name}`, say); the narrowest use wins, because that is the value the message needs.
+*/
+function typeOfArgument(uses) {
+	if (uses.some((u) => u.type === "plural" || u.type === "selectordinal" || u.type === "number")) return "number";
+	if (uses.some((u) => u.type === "date" || u.type === "time")) return "Date | number";
+	const select = uses.find((u) => u.type === "select");
+	if (select) {
+		const options = (select.selectors ?? []).filter((s) => s !== "other");
+		return options.length > 0 ? `${options.map((o) => JSON.stringify(o)).join(" | ")} | (string & {})` : "string";
+	}
+	return "string | number | boolean | Date";
+}
+/** `{ count: number; name: string | number | boolean | Date }` for the arguments of one message. */
+function messageType(message) {
+	if (!message.includes("{")) return void 0;
+	let args;
+	try {
+		args = getArguments(parseMessage(message));
+	} catch {
+		return;
+	}
+	if (args.length === 0) return void 0;
+	const byName = /* @__PURE__ */ new Map();
+	for (const arg of args) byName.set(arg.name, [...byName.get(arg.name) ?? [], arg]);
+	return `{ ${[...byName].map(([name, uses]) => `${IDENTIFIER.test(name) ? name : JSON.stringify(name)}: ${typeOfArgument(uses)}`).join("; ")} }`;
+}
+/**
+* `dictionary.key.path` to the type of its ICU values, read from each dictionary's reference
+* locale (the default locale when the dictionary has it, otherwise its first). Other locales must
+* use the same arguments, which `dx check` verifies.
+*/
+function messageArguments(dictionaries, defaultLocale) {
+	const result = {};
+	for (const df of dictionaries) {
+		if (!df?.name) continue;
+		const locales = listLocales(df);
+		const reference = locales.includes(defaultLocale) ? defaultLocale : locales[0];
+		if (!reference) continue;
+		for (const leaf of listLeaves(df, reference)) {
+			if (leaf.kind !== "string" || leaf.value === void 0) continue;
+			const type = messageType(leaf.value);
+			if (type) result[`${df.name}.${leaf.path.join(".")}`] = type;
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/utils/split-locales.ts
+const SKIPPED_KEYS = /* @__PURE__ */ new Set([
+	"loc",
+	"start",
+	"end",
+	"extra",
+	"range",
+	"comments",
+	"leadingComments",
+	"trailingComments",
+	"innerComments",
+	"tokens"
+]);
+/** Every identifier name used in a node, except property names that are not variable references. */
+function usedNames(node, found = /* @__PURE__ */ new Set()) {
+	if (!node || typeof node !== "object") return found;
+	if (Array.isArray(node)) {
+		node.forEach((child) => usedNames(child, found));
+		return found;
+	}
+	const ast = node;
+	if (ast.type === "Identifier") found.add(ast.name);
+	for (const key of Object.keys(ast)) {
+		if (SKIPPED_KEYS.has(key)) continue;
+		const isPropertyName = key === "key" && !ast.computed && [
+			"ObjectProperty",
+			"ObjectMethod",
+			"TSPropertySignature",
+			"TSMethodSignature"
+		].includes(ast.type);
+		const isMemberName = key === "property" && !ast.computed && (ast.type === "MemberExpression" || ast.type === "OptionalMemberExpression");
+		if (isPropertyName || isMemberName) continue;
+		usedNames(ast[key], found);
+	}
+	return found;
+}
+/** Names bound anywhere in a pattern (`const { a, b: [c] } = ...`). */
+function patternNames(pattern, found) {
+	if (!pattern) return;
+	switch (pattern.type) {
+		case "Identifier":
+			found.add(pattern.name);
+			break;
+		case "ObjectPattern":
+			for (const prop of pattern.properties) patternNames(prop.value ?? prop.argument, found);
+			break;
+		case "ArrayPattern":
+			for (const element of pattern.elements) patternNames(element ?? void 0, found);
+			break;
+		case "AssignmentPattern":
+			patternNames(pattern.left, found);
+			break;
+		case "RestElement": patternNames(pattern.argument, found);
+	}
+}
+/** What the file declares or imports at the top level: a locale that uses any of it cannot move. */
+function topLevelNames(df) {
+	const names = /* @__PURE__ */ new Set();
+	const program = df.mod.$ast;
+	const statements = program?.body ?? program?.program?.body ?? [];
+	for (const raw of statements) {
+		const statement = raw.type === "ExportNamedDeclaration" && raw.declaration ? raw.declaration : raw;
+		switch (statement.type) {
+			case "ImportDeclaration":
+				for (const specifier of statement.specifiers) names.add(specifier.local.name);
+				break;
+			case "VariableDeclaration":
+				for (const declarator of statement.declarations) patternNames(declarator.id, names);
+				break;
+			case "FunctionDeclaration":
+			case "ClassDeclaration":
+			case "TSInterfaceDeclaration":
+			case "TSTypeAliasDeclaration":
+			case "TSEnumDeclaration": if (statement.id?.name) names.add(statement.id.name);
+		}
+	}
+	return names;
+}
+/**
+* Cuts a dictionary into one self-contained piece per locale, for `lazy: "locale"`.
+*
+* A piece moves to its own file, so it must not depend on anything else in the original file.
+* That is checked conservatively: if a locale uses any name the file imports or declares (even one
+* that is only shadowed), the whole file is left alone. A missed split costs bytes; a wrong split
+* would break the app.
+*/
+function splitLocales(df) {
+	if (!df.complete) return {
+		ok: false,
+		reason: "it uses spreads, computed keys or non-literal locale values"
+	};
+	const bound = topLevelNames(df);
+	const slices = [];
+	for (const prop of df.localesObj.properties) {
+		const locale = keyName(prop);
+		const value = unwrap(prop.value);
+		if (locale === void 0 || !isObject(value)) return {
+			ok: false,
+			reason: "a locale is not an object literal"
+		};
+		const clash = [...usedNames(value)].find((name) => bound.has(name));
+		if (clash) return {
+			ok: false,
+			reason: `"${locale}" uses "${clash}", which is defined elsewhere in the file`
+		};
+		slices.push({
+			locale,
+			code: generateCode(value).code
+		});
+	}
+	if (slices.length === 0) return {
+		ok: false,
+		reason: "it defines no locales"
+	};
+	return {
+		ok: true,
+		slices
+	};
+}
+//#endregion
 //#region src/utils/static-config.ts
 const CONFIG_NAMES = ["dialex.config", "i18n.config"];
 const EXTENSIONS = [
@@ -865,7 +1030,7 @@ function apply(object, config, notes) {
 	accept("include", (v) => typeof v === "string" || isStringArray(v), "a string or array of strings");
 	accept("fallbacks", (v) => typeof v === "object" && v !== null && Object.values(v).every((list) => isStringArray(list)), "an object of string arrays");
 	accept("prefixDefault", (v) => typeof v === "boolean", "true or false");
-	accept("lazy", (v) => typeof v === "boolean", "true or false");
+	accept("lazy", (v) => typeof v === "boolean" || v === "locale", "true, false or \"locale\"");
 }
 /** Reads a config file's source text. Exposed for tests and for unsaved buffers. */
 function parseStaticConfig(text, file = "dialex.config.ts") {
@@ -925,6 +1090,313 @@ function readStaticConfig(root, configFile) {
 	};
 }
 //#endregion
+//#region src/utils/tsconfig.ts
+/** Parses tsconfig-style JSON: comments and trailing commas are allowed. */
+function parseJsonc(text) {
+	let out = "";
+	let inString = false;
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (inString) {
+			out += c;
+			if (c === "\\") out += text[++i] ?? "";
+			else if (c === "\"") inString = false;
+		} else if (c === "\"") {
+			inString = true;
+			out += c;
+		} else if (c === "/" && text[i + 1] === "/") {
+			while (i < text.length && text[i] !== "\n") i++;
+			out += "\n";
+		} else if (c === "/" && text[i + 1] === "*") {
+			i += 2;
+			while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+			i++;
+		} else out += c;
+	}
+	return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+function configFile(from) {
+	if (fs.existsSync(from) && fs.statSync(from).isFile()) return from;
+	for (const candidate of [`${from}.json`, path.join(from, "tsconfig.json")]) if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+}
+/** `moduleResolution` and `include` of a tsconfig, following relative `extends`. */
+function read(file, depth = 0) {
+	const result = { references: [] };
+	let json;
+	try {
+		json = parseJsonc(fs.readFileSync(file, "utf-8"));
+	} catch {
+		return result;
+	}
+	const dir = path.dirname(file);
+	const parent = typeof json.extends === "string" && json.extends.startsWith(".") && depth < 5 ? configFile(path.resolve(dir, json.extends)) : void 0;
+	if (parent) Object.assign(result, read(parent, depth + 1));
+	const options = json.compilerOptions ?? {};
+	const module = typeof options.module === "string" ? options.module.toLowerCase() : void 0;
+	const resolution = typeof options.moduleResolution === "string" ? options.moduleResolution.toLowerCase() : module === "node16" || module === "nodenext" ? module : void 0;
+	if (resolution) result.moduleResolution = resolution;
+	if (Array.isArray(json.include)) result.include = json.include;
+	result.references = (json.references ?? []).map((ref) => typeof ref?.path === "string" ? configFile(path.resolve(dir, ref.path)) : void 0).filter(Boolean);
+	return result;
+}
+/**
+* The extension for relative imports in generated files. TypeScript's `node16`/`nodenext` need
+* `./x.js`; bundlers (webpack, Vite) resolve extensionless imports, and webpack cannot map `.js`
+* to a `.ts` file. Without any tsconfig it is plain Node ESM, which needs the extension.
+*/
+function relativeImportExtension(root) {
+	const file = configFile(path.join(root, "tsconfig.json"));
+	if (!file) return ".js";
+	let resolved = read(file);
+	if (!resolved.moduleResolution && resolved.references.length > 0) {
+		const projects = resolved.references.map((ref) => read(ref));
+		resolved = projects.find((p) => p.include?.some((entry) => /^(\.\/)?src(\/|$)/.test(entry))) ?? projects[0] ?? resolved;
+	}
+	const resolution = resolved.moduleResolution;
+	return resolution === "node16" || resolution === "nodenext" ? ".js" : "";
+}
+//#endregion
+//#region src/commands/generate.ts
+const DICTIONARY_IGNORE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.next/**",
+	"**/dialex.locales/**"
+];
+/** The folder, next to `dialex.generated.ts`, that holds the per-locale modules. */
+const LOCALES_DIR = "dialex.locales";
+const safeName = (text) => text.replace(/[^A-Za-z0-9._-]/g, "_");
+/**
+* Works out `dialex.generated.ts` and `dialex-env.d.ts` for a project without writing anything,
+* so `check` can tell whether they are up to date.
+*
+* Settings come from `dialex.config.*` and fall back to {@link DEFAULT_CONFIG}; `locales` falls
+* back to the locales the dictionaries define.
+*/
+function renderGenerated(root, options = {}) {
+	const inlineConfig = options.config ? { configFile: options.config } : {};
+	const staticRead = readStaticConfig(root, options.config);
+	const config = options.static ? staticRead.config : resolveDialexConfig(root, inlineConfig);
+	const include = config.include || DEFAULT_CONFIG.include;
+	const found = fg.sync(include, {
+		cwd: root,
+		absolute: true,
+		ignore: DICTIONARY_IGNORE
+	}).sort();
+	const srcDir = fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root;
+	const outputPath = options.output ? path.resolve(root, options.output) : path.join(srcDir, "dialex.generated.ts");
+	const outputDir = path.dirname(outputPath);
+	const files = found.filter((file) => file !== outputPath && !file.endsWith(".d.ts") && path.basename(file) !== "dialex.generated.ts");
+	const parsed = files.map((file) => parseDictionaryText(file, fs.readFileSync(file, "utf-8")));
+	const inferred = [];
+	for (const df of parsed) if (df) {
+		for (const locale of listLocales(df)) if (!inferred.includes(locale)) inferred.push(locale);
+	}
+	const locales = config.locales?.length ? config.locales : inferred;
+	const clientConfig = {
+		defaultLocale: config.defaultLocale || DEFAULT_CONFIG.defaultLocale,
+		locales,
+		fallbacks: config.fallbacks ?? DEFAULT_CONFIG.fallbacks,
+		prefixDefault: config.prefixDefault ?? DEFAULT_CONFIG.prefixDefault,
+		lazy: config.lazy ?? DEFAULT_CONFIG.lazy
+	};
+	const extension = relativeImportExtension(root);
+	const importPath = (file) => {
+		let rel = path.relative(outputDir, file).replace(/\\/g, "/").replace(/\.ts$/, extension);
+		if (!rel.startsWith(".")) rel = "./" + rel;
+		return rel;
+	};
+	const header = `// Auto-generated by dialex CLI. Do not edit directly.
+/* eslint-disable */
+// @ts-nocheck`;
+	const configExport = `export const config = ${JSON.stringify(clientConfig, null, 2).replace("\"lazy\": \"locale\"", "\"lazy\": \"locale\" as const")};
+
+${locales.length > 0 ? `export const locales = ${JSON.stringify(locales)} as const;\nexport type Locale = (typeof locales)[number];` : "export const locales: readonly string[] = [];\nexport type Locale = string;"}`;
+	const extraFiles = [];
+	const notes = [];
+	const takenNames = /* @__PURE__ */ new Set();
+	let content;
+	if (clientConfig.lazy) content = `${header}
+
+export const dictionaries = [];
+
+export const dictionaryMap = {};
+
+export const loaders = {
+${files.map((file, i) => {
+		const df = parsed[i];
+		const name = df?.name;
+		if (!name || !df) throw new Error(`Cannot determine the dictionary name of ${path.relative(root, file)} for lazy loading. Use defineDictionary("name", ...) or a literal \`name\` property.`);
+		const whole = `  ${JSON.stringify(name)}: () => import("${importPath(file)}"),`;
+		if (clientConfig.lazy !== "locale") return whole;
+		const split = splitLocales(df);
+		if (!split.ok) {
+			notes.push(`${path.relative(root, file)} is loaded whole, not per locale: ${split.reason}.`);
+			return whole;
+		}
+		let base = safeName(name);
+		for (let n = 2; takenNames.has(base); n++) base = `${safeName(name)}-${n}`;
+		takenNames.add(base);
+		const entries = split.slices.map((slice) => {
+			const target = path.join(outputDir, LOCALES_DIR, `${base}.${safeName(slice.locale)}.ts`);
+			extraFiles.push({
+				path: target,
+				content: `${header}\nexport default ${slice.code};\n`
+			});
+			return `    ${JSON.stringify(slice.locale)}: () => import("${importPath(target)}"),`;
+		});
+		return `  ${JSON.stringify(name)}: {\n${entries.join("\n")}\n  },`;
+	}).join("\n")}
+};
+
+${configExport}
+
+export const dialex = { dictionaries, config, loaders };
+
+export default dictionaries;
+`;
+	else {
+		const ids = files.map((_, i) => `dict_${i}`);
+		const dictList = ids.length <= 1 ? `[${ids.join(", ")}]` : `[\n  ${ids.join(",\n  ")}\n]`;
+		content = `${header}
+${files.map((file, i) => `import ${ids[i]} from "${importPath(file)}";`).join("\n")}
+
+export const dictionaries = ${dictList};
+
+export const dictionaryMap = {
+${ids.map((id) => `  [${id}.name]: ${id}.dictionary,`).join("\n")}
+};
+
+${configExport}
+
+export const dialex = { dictionaries, config };
+
+export default dictionaries;
+`;
+	}
+	const dts = renderDts(root, files, locales, messageArguments(parsed, clientConfig.defaultLocale));
+	return {
+		files,
+		outputPath,
+		content,
+		dtsPath: dts?.path ?? path.join(srcDir, "dialex-env.d.ts"),
+		dtsContent: dts?.content,
+		configFile: staticRead.file,
+		extraFiles,
+		notes
+	};
+}
+function writeIfChanged(file, content) {
+	if ((fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : "") === content) return;
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	fs.writeFileSync(file, content, "utf-8");
+}
+function generateDictionaries(root, options = {}) {
+	const rendered = renderGenerated(root, options);
+	if (rendered.dtsContent !== void 0) writeIfChanged(rendered.dtsPath, rendered.dtsContent);
+	writeIfChanged(rendered.outputPath, rendered.content);
+	const dir = path.join(path.dirname(rendered.outputPath), LOCALES_DIR);
+	const wanted = new Set(rendered.extraFiles.map((f) => f.path));
+	for (const file of rendered.extraFiles) writeIfChanged(file.path, file.content);
+	if (fs.existsSync(dir)) {
+		for (const entry of fs.readdirSync(dir)) {
+			const full = path.join(dir, entry);
+			if (entry.endsWith(".ts") && !wanted.has(full)) fs.rmSync(full);
+		}
+		if (fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+	}
+	return {
+		files: rendered.files,
+		outputPath: rendered.outputPath,
+		dtsPath: rendered.dtsPath,
+		configFile: rendered.configFile,
+		notes: rendered.notes
+	};
+}
+async function runGenerate(options = {}) {
+	const root = options.cwd || process.cwd();
+	const quiet = options.json === true;
+	const doGenerate = () => {
+		try {
+			const { files, outputPath, dtsPath, configFile, notes } = generateDictionaries(root, options);
+			if (quiet) console.log(JSON.stringify({
+				success: true,
+				files: files.map((f) => path.relative(root, f)),
+				outputPath: path.relative(root, outputPath),
+				dtsPath: path.relative(root, dtsPath),
+				notes
+			}, null, 2));
+			else {
+				if (!configFile) logger.info("No dialex.config.* found, using defaults (run `dialex init` to add one).");
+				logger.success(`Generated dictionaries for ${files.length} file${files.length === 1 ? "" : "s"}:`);
+				logger.info(`→ ${path.relative(root, outputPath)}`);
+				logger.info(`→ ${path.relative(root, dtsPath)}`);
+				for (const note of notes) logger.info(note);
+			}
+			return true;
+		} catch (err) {
+			if (quiet) console.log(JSON.stringify({
+				success: false,
+				error: err.message || String(err)
+			}, null, 2));
+			else logger.error(`Generation failed: ${err.message || String(err)}`);
+			return false;
+		}
+	};
+	if (!doGenerate() && !options.watch) process.exit(1);
+	if (options.watch) {
+		logger.info("Watching for dictionary changes (-w, --watch)...");
+		startGenerateWatcher(root, options, doGenerate);
+	}
+}
+const WATCH_IGNORED = /(^|[\\/])(node_modules|dist|\.next|\.nuxt|\.output|\.turbo|\.git|dialex\.locales)([\\/]|$)/;
+const CONFIG_FILE = /(^|[\\/])(dialex|i18n)\.config\.[cm]?[jt]s(on)?$/;
+/**
+* Regenerates when a dictionary or config file is added, edited or removed. chokidar 4+ no longer
+* understands globs, so this watches the project directory and decides for itself which events
+* matter, using the same `include` glob as `generate`.
+*/
+function startGenerateWatcher(root, options, regenerate, delay = 100) {
+	const dictionaryFiles = () => new Set(renderGenerated(root, options).files);
+	let known = dictionaryFiles();
+	let outputs = /* @__PURE__ */ new Set();
+	let timer;
+	const trigger = () => {
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			regenerate();
+			try {
+				known = dictionaryFiles();
+				const rendered = renderGenerated(root, options);
+				outputs = /* @__PURE__ */ new Set([rendered.outputPath, rendered.dtsPath]);
+			} catch {}
+		}, delay);
+	};
+	const watcher = chokidar.watch(root, {
+		ignoreInitial: true,
+		ignored: (file) => WATCH_IGNORED.test(file)
+	});
+	watcher.on("all", (event, filePath) => {
+		const file = path.resolve(root, filePath);
+		if (outputs.has(file)) return;
+		const isConfig = CONFIG_FILE.test(file);
+		if (event === "change") {
+			if (!known.has(file) && !isConfig) return;
+		} else if (event === "add" || event === "unlink") {
+			let now;
+			try {
+				now = dictionaryFiles();
+			} catch {
+				return;
+			}
+			if (!(now.size !== known.size || [...now].some((f) => !known.has(f))) && !isConfig) return;
+		} else return;
+		logger.info(`[${event}] ${path.relative(root, file)} changed, regenerating...`);
+		trigger();
+	});
+	return watcher;
+}
+//#endregion
 //#region src/utils/project.ts
 async function loadDictionaries(root, config) {
 	const include = config.include || "**/*.content.ts";
@@ -934,7 +1406,8 @@ async function loadDictionaries(root, config) {
 		ignore: [
 			"**/node_modules/**",
 			"**/dist/**",
-			"**/.next/**"
+			"**/.next/**",
+			"**/dialex.locales/**"
 		]
 	});
 	const dictionaries = [];
@@ -963,7 +1436,7 @@ async function loadDictionaries(root, config) {
 * every dictionary file for AST-level reading and editing.
 */
 async function loadProject(root, configFile) {
-	const config = resolveI18nConfig(root, configFile ? { configFile } : {});
+	const config = resolveDialexConfig(root, configFile ? { configFile } : {});
 	return {
 		root,
 		config,
@@ -987,6 +1460,6 @@ async function loadStaticProject(root, configFile) {
 /** `home` + `["nav", "about"]` -> `home.nav.about` */
 const toKey = (dictionary, keyPath) => [dictionary, ...keyPath].join(".");
 //#endregion
-export { saveDictionaryFile as C, logger as D, runGenerate as E, renderDictionaryFile as S, generateDictionaries as T, listLeaves as _, parseStaticConfig as a, locationOf as b, analyzeProject as c, TODO_PREFIX as d, copyLeaf as f, hasPath as g, getString as h, DEFAULT_STATIC_CONFIG as i, relativeFile as l, getLeafSource as m, loadStaticProject as n, readStaticConfig as o, dictionaryLocation as p, toKey as r, DEFAULT_SOURCE_GLOB as s, loadProject as t, scanReferences as u, listLocales as v, setString as w, parseDictionaryText as x, loadDictionaryFile as y };
+export { listLocales as A, TODO_PREFIX as C, getString as D, getLeafSource as E, saveDictionaryFile as F, setString as I, locationOf as M, parseDictionaryText as N, hasPath as O, renderDictionaryFile as P, writeLock as S, dictionaryLocation as T, isStale as _, renderGenerated as a, readLock as b, parseStaticConfig as c, DEFAULT_SOURCE_GLOB as d, analyzeProject as f, hashSource as g, LOCK_FILE as h, generateDictionaries as i, loadDictionaryFile as j, listLeaves as k, readStaticConfig as l, scanReferences as m, loadStaticProject as n, runGenerate as o, relativeFile as p, toKey as r, DEFAULT_STATIC_CONFIG as s, loadProject as t, logger as u, lockFor as v, copyLeaf as w, record as x, lockPath as y };
 
-//# sourceMappingURL=project-BnG6V2I0.mjs.map
+//# sourceMappingURL=project-BJYmnKiU.mjs.map