@dialexjs/cli 0.7.2 → 0.9.2

package/dist/{project-Dz0FbydQ.mjs → project-BTpZGNjh.mjs}

@@ -1,8 +1,8 @@
-import fs from "node:fs";
 import path from "node:path";
 import pc from "picocolors";
-import { pathToFileURL } from "node:url";
+import fs from "node:fs";
 import { generateCode, parseExpression, parseModule, writeFile } from "magicast";
+import { pathToFileURL } from "node:url";
 import fg from "fast-glob";
 import ignore from "ignore";
 import { argumentSignature, findPlurals, getArguments, isIcuStructured, parseMessage } from "dialexjs/icu";
@@ -10,60 +10,68 @@ import { createHash } from "node:crypto";
 import { DEFAULT_CONFIG } from "dialexjs";
 import { loadConfigSync } from "unconfig";
 import chokidar from "chokidar";
-//#region src/utils/dictionary-edit.ts
+//#region src/utils/dictionary/types.ts
 const TODO_PREFIX = "[TODO] ";
-const IDENTIFIER$1 = /^[A-Za-z_$][\w$]*$/;
-function unwrap(node) {
+//#endregion
+//#region src/utils/ast.ts
+/** Strips `as`, `satisfies` and parentheses around an expression. */
+function unwrapNode(node) {
 	while (node && (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "ParenthesizedExpression")) node = node.expression;
 	return node;
 }
-const isObject = (node) => node?.type === "ObjectExpression";
-function keyName(prop) {
+const isObjectNode = (node) => node?.type === "ObjectExpression";
+/** The static name of a property key, or `undefined` when it is computed. */
+function propertyKeyName(prop) {
 	const key = prop?.key;
 	if (!key || prop.computed) return void 0;
 	if (key.type === "Identifier") return key.name;
 	if (key.type === "StringLiteral" || key.type === "Literal" && typeof key.value === "string") return key.value;
 	if (key.type === "NumericLiteral") return String(key.value);
 }
-const isPropLike = (p) => p?.type === "ObjectProperty" || p?.type === "Property" || p?.type === "ObjectMethod";
-function findProp(obj, key) {
-	return obj.properties.find((p) => isPropLike(p) && keyName(p) === key);
+const isPropLike$1 = (p) => p?.type === "ObjectProperty" || p?.type === "Property" || p?.type === "ObjectMethod";
+/** The first property of `obj` with the static name `key`. */
+function findProperty(obj, key) {
+	return obj.properties.find((p) => isPropLike$1(p) && propertyKeyName(p) === key);
 }
+//#endregion
+//#region src/utils/dictionary/ast-helpers.ts
+const IDENTIFIER$1 = /^[A-Za-z_$][\w$]*$/;
+const isPropLike = (p) => p?.type === "ObjectProperty" || p?.type === "Property" || p?.type === "ObjectMethod";
 function stringValue(node) {
-	node = unwrap(node);
+	node = unwrapNode(node);
 	if (node?.type === "StringLiteral") return node.value;
 	if (node?.type === "Literal" && typeof node.value === "string") return node.value;
 	if (node?.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value?.cooked ?? void 0;
 }
 function leafKind(node) {
-	node = unwrap(node);
+	node = unwrapNode(node);
 	if (stringValue(node) !== void 0) return "string";
 	if (node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "ObjectMethod") return "function";
 	return "other";
 }
 function dictionaryProp(obj) {
-	const value = unwrap(findProp(obj, "dictionary")?.value);
-	return isObject(value) ? value : void 0;
+	const value = unwrapNode(findProperty(obj, "dictionary")?.value);
+	return isObjectNode(value) ? value : void 0;
 }
 function locateName(declaration) {
-	const decl = unwrap(declaration);
+	const decl = unwrapNode(declaration);
 	if (decl?.type === "CallExpression") {
-		const first = unwrap(decl.arguments[0]);
-		if (isObject(first)) return stringValue(findProp(first, "name")?.value);
+		const first = unwrapNode(decl.arguments[0]);
+		if (isObjectNode(first)) return stringValue(findProperty(first, "name")?.value);
 		return stringValue(first);
 	}
-	if (isObject(decl)) return stringValue(findProp(decl, "name")?.value);
+	if (isObjectNode(decl)) return stringValue(findProperty(decl, "name")?.value);
 }
 function locateLocalesObject(declaration) {
-	const decl = unwrap(declaration);
+	const decl = unwrapNode(declaration);
 	if (decl?.type === "CallExpression") {
-		const first = unwrap(decl.arguments[0]);
-		const second = unwrap(decl.arguments[1]);
-		if (isObject(second)) return second;
-		if (isObject(first)) return dictionaryProp(first);
+		const first = unwrapNode(decl.arguments[0]);
+		const second = unwrapNode(decl.arguments[1]);
+		if (isObjectNode(second)) return second;
+		if (isObjectNode(first)) return dictionaryProp(first);
 		return;
 	}
-	if (isObject(decl)) return dictionaryProp(decl);
+	if (isObjectNode(decl)) return dictionaryProp(decl);
 }
 /** Quotes a property key only when it is not a valid identifier. */
 function keyCode(key) {
@@ -82,17 +90,19 @@ function makeStringNode(value) {
 */
 function isStaticallyComplete(localesObj) {
 	const walk = (obj) => obj.properties.every((prop) => {
-		if (!isPropLike(prop) || keyName(prop) === void 0) return false;
+		if (!isPropLike(prop) || propertyKeyName(prop) === void 0) return false;
 		if (prop.type === "ObjectMethod") return true;
-		const value = unwrap(prop.value);
-		return isObject(value) ? walk(value) : true;
+		const value = unwrapNode(prop.value);
+		return isObjectNode(value) ? walk(value) : true;
 	});
 	return localesObj.properties.every((prop) => {
-		if (!isPropLike(prop) || keyName(prop) === void 0 || prop.type === "ObjectMethod") return false;
-		const value = unwrap(prop.value);
-		return isObject(value) && walk(value);
+		if (!isPropLike(prop) || propertyKeyName(prop) === void 0 || prop.type === "ObjectMethod") return false;
+		const value = unwrapNode(prop.value);
+		return isObjectNode(value) && walk(value);
 	});
 }
+//#endregion
+//#region src/utils/dictionary/io.ts
 /**
 * Parses dictionary source text (for example an unsaved editor buffer). Returns `undefined` when
 * the file does not have an editable shape; throws on syntax errors.
@@ -128,12 +138,14 @@ async function saveDictionaryFile(df) {
 		if (!text.endsWith("\n")) fs.writeFileSync(df.file, text + "\n", "utf-8");
 	}
 }
+//#endregion
+//#region src/utils/dictionary/read.ts
 function listLocales(df) {
-	return df.localesObj.properties.filter(isPropLike).map(keyName).filter((k) => k !== void 0);
+	return df.localesObj.properties.filter(isPropLike).map(propertyKeyName).filter((k) => k !== void 0);
 }
 function localeObject(df, locale) {
-	const value = unwrap(findProp(df.localesObj, locale)?.value);
-	return isObject(value) ? value : void 0;
+	const value = unwrapNode(findProperty(df.localesObj, locale)?.value);
+	return isObjectNode(value) ? value : void 0;
 }
 /** Lists every leaf (string, function, or other value) of a locale, in source order. */
 function listLeaves(df, locale) {
@@ -143,11 +155,11 @@ function listLeaves(df, locale) {
 	const walk = (obj, prefix) => {
 		for (const prop of obj.properties) {
 			if (!isPropLike(prop)) continue;
-			const name = keyName(prop);
+			const name = propertyKeyName(prop);
 			if (name === void 0) continue;
 			const path = [...prefix, name];
-			const value = prop.type === "ObjectMethod" ? prop : unwrap(prop.value);
-			if (isObject(value)) walk(value, path);
+			const value = prop.type === "ObjectMethod" ? prop : unwrapNode(prop.value);
+			if (isObjectNode(value)) walk(value, path);
 			else {
 				const kind = leafKind(value);
 				leaves.push({
@@ -164,11 +176,11 @@ function listLeaves(df, locale) {
 function getProp(df, locale, path) {
 	let obj = localeObject(df, locale);
 	for (let i = 0; obj && i < path.length; i++) {
-		const prop = findProp(obj, path[i]);
+		const prop = findProperty(obj, path[i]);
 		if (!prop) return void 0;
 		if (i === path.length - 1) return prop;
-		const next = unwrap(prop.value);
-		obj = isObject(next) ? next : void 0;
+		const next = unwrapNode(prop.value);
+		obj = isObjectNode(next) ? next : void 0;
 	}
 }
 function hasPath(df, locale, path) {
@@ -178,6 +190,13 @@ function getString(df, locale, path) {
 	const prop = getProp(df, locale, path);
 	return prop && prop.type !== "ObjectMethod" ? stringValue(prop.value) : void 0;
 }
+/** Leaf paths of a runtime dictionary value (plain objects recurse; everything else is a leaf). */
+function flattenPaths(value, prefix = []) {
+	if (value && typeof value === "object" && !Array.isArray(value)) return Object.entries(value).flatMap(([k, v]) => flattenPaths(v, [...prefix, k]));
+	return prefix.length > 0 ? [prefix] : [];
+}
+//#endregion
+//#region src/utils/dictionary/write.ts
 function ensureLocale(df, locale) {
 	let obj = localeObject(df, locale);
 	if (!obj) {
@@ -191,13 +210,13 @@ function ensureLocale(df, locale) {
 function ensureParent(df, locale, path) {
 	let obj = ensureLocale(df, locale);
 	for (const segment of path.slice(0, -1)) {
-		let prop = findProp(obj, segment);
+		let prop = findProperty(obj, segment);
 		if (!prop) {
 			prop = makeProp(segment, "{}");
 			obj.properties.push(prop);
 		}
-		const next = unwrap(prop.value);
-		if (!isObject(next)) return void 0;
+		const next = unwrapNode(prop.value);
+		if (!isObjectNode(next)) return void 0;
 		obj = next;
 	}
 	return obj;
@@ -210,7 +229,7 @@ function setString(df, locale, path, value) {
 	const parent = ensureParent(df, locale, path);
 	if (!parent) return "skipped";
 	const last = path[path.length - 1];
-	const existing = findProp(parent, last);
+	const existing = findProperty(parent, last);
 	if (existing) {
 		if (existing.type === "ObjectMethod" || leafKind(existing.value) !== "string") return "skipped";
 		existing.value = makeStringNode(value);
@@ -239,11 +258,8 @@ function copyLeaf(df, fromLocale, toLocale, path, mapString) {
 	}
 	return true;
 }
-/** Leaf paths of a runtime dictionary value (plain objects recurse; everything else is a leaf). */
-function flattenPaths(value, prefix = []) {
-	if (value && typeof value === "object" && !Array.isArray(value)) return Object.entries(value).flatMap(([k, v]) => flattenPaths(v, [...prefix, k]));
-	return prefix.length > 0 ? [prefix] : [];
-}
+//#endregion
+//#region src/utils/dictionary/locations.ts
 const toRange = (loc) => loc ? {
 	start: {
 		line: loc.start.line - 1,
@@ -259,7 +275,7 @@ const toRange = (loc) => loc ? {
 * it is a good place to attach a diagnostic or jump to.
 */
 function locationOf(df, locale, path = []) {
-	const prop = path.length === 0 ? findProp(df.localesObj, locale) : getProp(df, locale, path);
+	const prop = path.length === 0 ? findProperty(df.localesObj, locale) : getProp(df, locale, path);
 	return toRange((prop?.key ?? prop)?.loc);
 }
 /** The source text of the dictionary object itself (the object whose keys are locales). */
@@ -273,6 +289,153 @@ function getLeafSource(df, locale, path) {
 	return generateCode(prop.type === "ObjectMethod" ? prop : prop.value).code;
 }
 //#endregion
+//#region src/analysis/cache.ts
+function createAnalysisCache() {
+	return {
+		dictionaries: /* @__PURE__ */ new Map(),
+		sources: /* @__PURE__ */ new Map(),
+		gitignore: /* @__PURE__ */ new Map()
+	};
+}
+/** Forget the cached `.gitignore` rules, for example after a `.gitignore` file changed. */
+function clearGitignore(cache) {
+	cache.gitignore.clear();
+}
+function stampOf(file) {
+	try {
+		const stat = fs.statSync(file);
+		return `${stat.mtimeMs}:${stat.size}`;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/analysis/load-dictionary.ts
+function fromSyntaxTree(df) {
+	const locales = listLocales(df);
+	const leaves = /* @__PURE__ */ new Map();
+	for (const locale of locales) {
+		const entries = /* @__PURE__ */ new Map();
+		for (const leaf of listLeaves(df, locale)) entries.set(leaf.path.join("."), {
+			kind: leaf.kind,
+			value: leaf.value
+		});
+		leaves.set(locale, entries);
+	}
+	return {
+		name: df.name,
+		locales,
+		leaves,
+		df
+	};
+}
+async function fromRuntime(file) {
+	try {
+		const mod = await import(`${pathToFileURL(file).href}?t=${Date.now()}_${Math.random()}`);
+		const definition = mod.default || mod;
+		if (!definition || typeof definition !== "object" || !definition.dictionary) return {
+			ok: false,
+			level: "error",
+			code: "invalid-dictionary",
+			message: "Default export does not appear to be a valid defineDictionary output."
+		};
+		const dictionary = definition.dictionary;
+		const leaves = /* @__PURE__ */ new Map();
+		const invalid = [];
+		for (const [locale, content] of Object.entries(dictionary)) {
+			if (!content || typeof content !== "object") {
+				invalid.push(locale);
+				continue;
+			}
+			const entries = /* @__PURE__ */ new Map();
+			for (const leafPath of flattenPaths(content)) {
+				let value = content;
+				for (const segment of leafPath) value = value?.[segment];
+				entries.set(leafPath.join("."), typeof value === "string" ? {
+					kind: "string",
+					value
+				} : { kind: typeof value === "function" ? "function" : "other" });
+			}
+			leaves.set(locale, entries);
+		}
+		if (invalid.length > 0) return {
+			ok: false,
+			level: "error",
+			code: "invalid-locale",
+			message: invalid.map((l) => `Locale "${l}" content is empty or invalid.`).join("\n")
+		};
+		return {
+			ok: true,
+			data: {
+				name: String(definition.name ?? ""),
+				locales: [...leaves.keys()],
+				leaves
+			}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			level: "error",
+			code: "invalid-dictionary",
+			message: `Failed to import dictionary: ${error.message || String(error)}`
+		};
+	}
+}
+function fromParsed(parsed) {
+	try {
+		const df = parsed();
+		if (df?.complete && df.name) return {
+			ok: true,
+			data: fromSyntaxTree(df)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			level: "error",
+			code: "invalid-dictionary",
+			message: `Failed to parse dictionary: ${error.message}`
+		};
+	}
+}
+const UNANALYZABLE = {
+	ok: false,
+	level: "info",
+	code: "unanalyzable",
+	message: "This dictionary uses spreads, computed keys, imported values, or a computed name, so it cannot be analyzed statically."
+};
+/** Reads a dictionary from its syntax tree. Never runs project code. */
+function loadDictionaryDataStatic(file) {
+	return fromParsed(() => parseDictionaryText(file, fs.readFileSync(file, "utf-8"))) ?? UNANALYZABLE;
+}
+async function loadDictionaryData(file, runtime) {
+	const parsed = fromParsed(() => parseDictionaryText(file, fs.readFileSync(file, "utf-8")));
+	if (parsed?.ok) return parsed;
+	if (runtime) return fromRuntime(file);
+	return parsed ?? UNANALYZABLE;
+}
+async function cachedDictionary(file, runtime, cache) {
+	const stamp = cache ? stampOf(file) : void 0;
+	const hit = stamp ? cache.dictionaries.get(file) : void 0;
+	if (hit && hit.stamp === stamp) return hit.loaded;
+	const loaded = await loadDictionaryData(file, runtime);
+	if (cache && stamp) cache.dictionaries.set(file, {
+		stamp,
+		loaded
+	});
+	return loaded;
+}
+function cachedDictionaryStatic(file, cache) {
+	const stamp = cache ? stampOf(file) : void 0;
+	const hit = stamp ? cache.dictionaries.get(file) : void 0;
+	if (hit && hit.stamp === stamp) return hit.loaded;
+	const loaded = loadDictionaryDataStatic(file);
+	if (cache && stamp) cache.dictionaries.set(file, {
+		stamp,
+		loaded
+	});
+	return loaded;
+}
+//#endregion
 //#region src/utils/files.ts
 /** Folders that never hold project dictionaries or sources, in every scanner. */
 const BUILTIN_IGNORE = [
@@ -517,29 +680,121 @@ function lockFor(root, sourceLocale) {
 	};
 }
 //#endregion
-//#region src/analysis.ts
-function createAnalysisCache() {
-	return {
-		dictionaries: /* @__PURE__ */ new Map(),
-		sources: /* @__PURE__ */ new Map(),
-		gitignore: /* @__PURE__ */ new Map()
-	};
-}
-/** Forget the cached `.gitignore` rules, for example after a `.gitignore` file changed. */
-function clearGitignore(cache) {
-	cache.gitignore.clear();
-}
+//#region src/analysis/source-scan.ts
 const DEFAULT_SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte,astro,mdx}";
 /** `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. */
-function scanReferences(text) {
+/**
+* Offsets of `//`, `/* *\/` and `<!-- -->` comments. Quoted strings are skipped so `"http://x"`
+* is not a comment; `'` and `"` end at a newline, template literals do not.
+*/
+function commentRanges(text) {
+	const ranges = [];
+	const length = text.length;
+	let i = 0;
+	while (i < length) {
+		const c = text[i];
+		if (c === "\"" || c === "'" || c === "`") {
+			i++;
+			while (i < length && text[i] !== c && (c === "`" || text[i] !== "\n")) {
+				if (text[i] === "\\") i++;
+				i++;
+			}
+			i++;
+			continue;
+		}
+		let close;
+		if (c === "/" && text[i + 1] === "/") close = "\n";
+		else if (c === "/" && text[i + 1] === "*") close = "*/";
+		else if (c === "<" && text.startsWith("<!--", i)) close = "-->";
+		if (close === void 0) {
+			i++;
+			continue;
+		}
+		const found = text.indexOf(close, i + 2);
+		const end = found === -1 ? length : close === "\n" ? found : found + close.length;
+		ranges.push([i, end]);
+		i = end;
+	}
+	return ranges;
+}
+const IGNORE_DIRECTIVE = /dialex-ignore(-next-line)?(?![\w-])/;
+/** `dictionaries: { name: ..., "other-name": ..., shorthand }`, up to the first key. */
+const DICTIONARIES_OBJECT = /\bdictionaries\s*:\s*\{/g;
+const OBJECT_KEY = /\s*(?:([A-Za-z_$][\w$-]*)|(["'])([^"'\n]+)\2)\s*(?=[:,}])/y;
+/** Replaces comments with spaces of the same length, keeping offsets and line breaks. */
+function maskComments(text, comments) {
+	if (comments.length === 0) return text;
+	let out = "";
+	let at = 0;
+	for (const [from, to] of comments) {
+		out += text.slice(at, from) + text.slice(from, to).replace(/[^\n]/g, " ");
+		at = to;
+	}
+	return out + text.slice(at);
+}
+/** Names that an object literal `dictionaries: { ... }` registers inline. */
+function inlineDictionaryNames(masked) {
+	const names = /* @__PURE__ */ new Set();
+	for (const match of masked.matchAll(DICTIONARIES_OBJECT)) {
+		let i = match.index + match[0].length;
+		let depth = 1;
+		let expectKey = true;
+		while (i < masked.length && depth > 0) {
+			if (expectKey && depth === 1) {
+				OBJECT_KEY.lastIndex = i;
+				const key = OBJECT_KEY.exec(masked);
+				if (key) {
+					names.add(key[1] ?? key[3]);
+					i = OBJECT_KEY.lastIndex;
+				}
+				expectKey = false;
+				continue;
+			}
+			const c = masked[i];
+			if (c === "\"" || c === "'" || c === "`") {
+				i++;
+				while (i < masked.length && masked[i] !== c && (c === "`" || masked[i] !== "\n")) {
+					if (masked[i] === "\\") i++;
+					i++;
+				}
+			} else if (c === "{" || c === "[" || c === "(") depth++;
+			else if (c === "}" || c === "]" || c === ")") depth--;
+			else if (c === "," && depth === 1) expectKey = true;
+			i++;
+		}
+	}
+	return [...names];
+}
+/** Lines that a `dialex-ignore` / `dialex-ignore-next-line` comment excludes from checking. */
+function ignoredLines(text, comments) {
+	const lines = /* @__PURE__ */ new Set();
+	if (!text.includes("dialex-ignore")) return lines;
+	const starts = lineStarts(text);
+	for (const [from, to] of comments) {
+		const directive = IGNORE_DIRECTIVE.exec(text.slice(from, to));
+		if (!directive) continue;
+		const first = positionAt(starts, from).line;
+		const last = positionAt(starts, Math.max(from, to - 1)).line;
+		if (directive[1]) lines.add(last + 1);
+		else for (let line = first; line <= last; line++) lines.add(line);
+	}
+	return lines;
+}
+/** References and inline dictionary names found in one source file. */
+function scanText(text) {
+	const comments = commentRanges(text);
+	const ignored = ignoredLines(text, comments);
+	const starts = ignored.size > 0 ? lineStarts(text) : [];
+	const inComment = (offset) => comments.some(([from, to]) => offset >= from && offset < to);
 	const references = [];
 	const collect = (pattern, kind) => {
 		for (const match of text.matchAll(pattern)) {
 			const [start, end] = match.indices[2];
+			if (comments.length > 0 && inComment(start)) continue;
+			if (ignored.size > 0 && ignored.has(positionAt(starts, start).line)) continue;
 			references.push({
 				kind,
 				value: match[2],
@@ -550,7 +805,18 @@ function scanReferences(text) {
 	};
 	collect(DICTIONARY_CALL, "dictionary");
 	collect(T_CALL, "path");
-	return references.sort((a, b) => a.start - b.start);
+	references.sort((a, b) => a.start - b.start);
+	return {
+		references,
+		inline: text.includes("dictionaries") ? inlineDictionaryNames(maskComments(text, comments)) : []
+	};
+}
+/**
+* Finds `getDictionary("x")`-style and `t("x.y.z")` references in source text. References inside
+* comments, and on lines a `dialex-ignore` comment covers, are skipped.
+*/
+function scanReferences(text) {
+	return scanText(text).references;
 }
 function lineStarts(text) {
 	const starts = [0];
@@ -570,134 +836,34 @@ function positionAt(starts, offset) {
 		column: offset - starts[low]
 	};
 }
-function fromSyntaxTree(df) {
-	const locales = listLocales(df);
-	const leaves = /* @__PURE__ */ new Map();
-	for (const locale of locales) {
-		const entries = /* @__PURE__ */ new Map();
-		for (const leaf of listLeaves(df, locale)) entries.set(leaf.path.join("."), {
-			kind: leaf.kind,
-			value: leaf.value
-		});
-		leaves.set(locale, entries);
-	}
-	return {
-		name: df.name,
-		locales,
-		leaves,
-		df
-	};
-}
-async function fromRuntime(file) {
-	try {
-		const mod = await import(`${pathToFileURL(file).href}?t=${Date.now()}_${Math.random()}`);
-		const definition = mod.default || mod;
-		if (!definition || typeof definition !== "object" || !definition.dictionary) return {
-			ok: false,
-			level: "error",
-			code: "invalid-dictionary",
-			message: "Default export does not appear to be a valid defineDictionary output."
-		};
-		const dictionary = definition.dictionary;
-		const leaves = /* @__PURE__ */ new Map();
-		const invalid = [];
-		for (const [locale, content] of Object.entries(dictionary)) {
-			if (!content || typeof content !== "object") {
-				invalid.push(locale);
-				continue;
-			}
-			const entries = /* @__PURE__ */ new Map();
-			for (const leafPath of flattenPaths(content)) {
-				let value = content;
-				for (const segment of leafPath) value = value?.[segment];
-				entries.set(leafPath.join("."), typeof value === "string" ? {
-					kind: "string",
-					value
-				} : { kind: typeof value === "function" ? "function" : "other" });
-			}
-			leaves.set(locale, entries);
-		}
-		if (invalid.length > 0) return {
-			ok: false,
-			level: "error",
-			code: "invalid-locale",
-			message: invalid.map((l) => `Locale "${l}" content is empty or invalid.`).join("\n")
-		};
-		return {
-			ok: true,
-			data: {
-				name: String(definition.name ?? ""),
-				locales: [...leaves.keys()],
-				leaves
-			}
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			level: "error",
-			code: "invalid-dictionary",
-			message: `Failed to import dictionary: ${error.message || String(error)}`
-		};
-	}
-}
-async function loadDictionaryData(file, runtime) {
-	let astError;
-	try {
-		const df = await loadDictionaryFile(file);
-		if (df?.complete && df.name) return {
-			ok: true,
-			data: fromSyntaxTree(df)
-		};
-	} catch (error) {
-		astError = error;
-	}
-	if (runtime) return fromRuntime(file);
-	return astError ? {
-		ok: false,
-		level: "error",
-		code: "invalid-dictionary",
-		message: `Failed to parse dictionary: ${astError.message}`
-	} : {
-		ok: false,
-		level: "info",
-		code: "unanalyzable",
-		message: "This dictionary uses spreads, computed keys, imported values, or a computed name, so it cannot be analyzed statically."
-	};
-}
-function stampOf(file) {
-	try {
-		const stat = fs.statSync(file);
-		return `${stat.mtimeMs}:${stat.size}`;
-	} catch {
-		return;
-	}
-}
-async function cachedDictionary(file, runtime, cache) {
-	const stamp = cache ? stampOf(file) : void 0;
-	const hit = stamp ? cache.dictionaries.get(file) : void 0;
-	if (hit && hit.stamp === stamp) return hit.loaded;
-	const loaded = await loadDictionaryData(file, runtime);
-	if (cache && stamp) cache.dictionaries.set(file, {
-		stamp,
-		loaded
-	});
-	return loaded;
-}
 function scanSource(text) {
 	const starts = lineStarts(text);
 	const rangeOf = (start, end) => ({
 		start: positionAt(starts, start),
 		end: positionAt(starts, end)
 	});
+	const { references, inline } = scanText(text);
 	return {
 		tokens: [...new Set(text.match(/[\w$-]+/g) ?? [])],
-		refs: scanReferences(text).map((ref) => ({
+		refs: references.map((ref) => ({
 			ref,
 			range: rangeOf(ref.start, ref.end)
-		}))
+		})),
+		inline
 	};
 }
-async function analyzeProject(options) {
+//#endregion
+//#region src/analysis/steps.ts
+function lintLevel(setting) {
+	const level = Array.isArray(setting) ? setting[0] : setting;
+	return level === "off" || level === "warn" || level === "error" ? level : void 0;
+}
+/**
+* The analysis itself, written once. It yields a `LoadRequest` for every dictionary so that a
+* synchronous driver (`analyzeProjectSync`) and an asynchronous one (`analyzeProject`, which may
+* import dictionaries at runtime) can share it.
+*/
+function* analysisSteps(options) {
 	const { root, config } = options;
 	const include = config.include || "**/*.content.ts";
 	const configuredLocales = config.locales || [];
@@ -718,7 +884,12 @@ async function analyzeProject(options) {
 	const dictionaries = [];
 	const lock = options.lock === false ? void 0 : readLock(root);
 	for (const file of files) {
-		const loaded = await cachedDictionary(file, options.runtime === true, cache);
+		const loaded = yield {
+			file,
+			runtime: options.runtime === true,
+			cache,
+			text: options.contents?.get(file)
+		};
 		if (!loaded.ok) {
 			for (const message of loaded.message.split("\n")) issues.push({
 				file,
@@ -831,8 +1002,10 @@ async function analyzeProject(options) {
 		ignore: extraIgnore,
 		gitignoreFilter: gitignore
 	}).filter((f) => !dictionaryFiles.has(f));
+	const inline = /* @__PURE__ */ new Set();
 	if (sourceFiles.length > 0) {
 		const tokens = /* @__PURE__ */ new Set();
+		const scans = [];
 		for (const file of sourceFiles) {
 			const stamp = cache ? stampOf(file) : void 0;
 			let scan = stamp ? cache.sources.get(file) : void 0;
@@ -850,32 +1023,37 @@ async function analyzeProject(options) {
 				if (cache && stamp) cache.sources.set(file, scan);
 			}
 			for (const token of scan.scan.tokens) tokens.add(token);
-			for (const { ref, range } of scan.scan.refs) {
-				if (ref.kind === "dictionary") {
-					if (!known.has(ref.value)) issues.push({
-						file,
-						level: "error",
-						code: "unknown-dictionary",
-						message: `Unknown dictionary "${ref.value}"`,
-						range,
-						dictionary: ref.value
-					});
-					continue;
-				}
-				const [name, ...rest] = ref.value.split(".");
-				const dictionary = known.get(name);
-				if (!dictionary) continue;
-				const keyPath = rest.join(".");
-				if (!dictionary.paths.some((p) => p === keyPath || p.startsWith(`${keyPath}.`))) issues.push({
+			scans.push({
+				file,
+				scan: scan.scan
+			});
+		}
+		for (const { scan } of scans) for (const name of scan.inline) inline.add(name);
+		for (const { file, scan } of scans) for (const { ref, range } of scan.refs) {
+			if (ref.kind === "dictionary") {
+				if (!known.has(ref.value) && !inline.has(ref.value)) issues.push({
 					file,
 					level: "error",
-					code: "unknown-path",
-					message: `Unknown translation path "${ref.value}"`,
+					code: "unknown-dictionary",
+					message: `Unknown dictionary "${ref.value}"`,
 					range,
-					dictionary: name,
-					path: rest
+					dictionary: ref.value
 				});
+				continue;
 			}
+			const [name, ...rest] = ref.value.split(".");
+			const dictionary = known.get(name);
+			if (!dictionary) continue;
+			const keyPath = rest.join(".");
+			if (!dictionary.paths.some((p) => p === keyPath || p.startsWith(`${keyPath}.`))) issues.push({
+				file,
+				level: "error",
+				code: "unknown-path",
+				message: `Unknown translation path "${ref.value}"`,
+				range,
+				dictionary: name,
+				path: rest
+			});
 		}
 		if (options.unused !== false) for (const dictionary of dictionaries) {
 			if (!tokens.has(dictionary.name)) {
@@ -909,13 +1087,49 @@ async function analyzeProject(options) {
 		const live = /* @__PURE__ */ new Set([...files, ...sourceFiles]);
 		for (const map of [cache.dictionaries, cache.sources]) for (const key of map.keys()) if (key.startsWith(root) && !live.has(key)) map.delete(key);
 	}
+	const rules = config.lint?.rules;
+	if (rules && Object.keys(rules).length > 0) for (let i = issues.length - 1; i >= 0; i--) {
+		const level = lintLevel(rules[issues[i].code]);
+		if (!level) continue;
+		if (level === "off") issues.splice(i, 1);
+		else issues[i].level = level === "error" ? "error" : "warning";
+	}
 	return {
 		issues,
 		dictionaries,
 		files,
-		sourceFilesScanned: sourceFiles.length
+		sourceFilesScanned: sourceFiles.length,
+		inlineDictionaries: [...inline]
 	};
 }
+//#endregion
+//#region src/analysis/index.ts
+/** Analyzes a project. With `runtime: true`, dictionaries the syntax tree cannot describe are imported. */
+async function analyzeProject(options) {
+	const steps = analysisSteps(options);
+	let step = steps.next();
+	while (!step.done) {
+		const { file, runtime, cache, text } = step.value;
+		step = steps.next(text === void 0 ? await cachedDictionary(file, runtime, cache) : fromParsed(() => parseDictionaryText(file, text)) ?? UNANALYZABLE);
+	}
+	return step.value;
+}
+/**
+* `analyzeProject` for callers that cannot await, such as lint rules. Reads dictionaries from the
+* syntax tree only: `runtime` is ignored, so project code is never executed.
+*/
+function analyzeProjectSync(options) {
+	const steps = analysisSteps({
+		...options,
+		runtime: false
+	});
+	let step = steps.next();
+	while (!step.done) {
+		const { file, cache, text } = step.value;
+		step = steps.next(text === void 0 ? cachedDictionaryStatic(file, cache) : fromParsed(() => parseDictionaryText(file, text)) ?? UNANALYZABLE);
+	}
+	return step.value;
+}
 /** Project root-relative path with forward slashes, for display. */
 function relativeFile(root, file) {
 	return path.relative(root, file);
@@ -930,44 +1144,48 @@ const logger = {
 	log: (msg) => console.log(msg)
 };
 //#endregion
+//#region src/utils/load-config.ts
+/**
+* Runs the first config file that exists (`dialex.config.*`, then `i18n.config.*`, or
+* `configFile`) with `unconfig` and returns what it exports. **This executes project code.**
+* Returns `undefined` when the project has no config file; throws what the file throws.
+*/
+function loadConfigObject(root, configFile) {
+	const sources = [];
+	if (configFile) sources.push({ files: configFile });
+	for (const name of ["dialex.config", "i18n.config"]) sources.push({
+		files: name,
+		extensions: [
+			"ts",
+			"mts",
+			"cts",
+			"js",
+			"mjs",
+			"cjs",
+			"json",
+			""
+		]
+	});
+	const result = loadConfigSync({
+		sources,
+		merge: false,
+		defaults: {},
+		cwd: root
+	});
+	const file = result?.sources?.[0];
+	if (!file) return void 0;
+	return {
+		config: result.config && typeof result.config === "object" ? result.config : {},
+		file
+	};
+}
+//#endregion
 //#region src/utils/scanner.ts
 function resolveDialexConfig(root, inlineConfig = {}) {
 	let loadedConfig = {};
 	try {
-		const sources = [];
-		if (inlineConfig.configFile) sources.push({ files: inlineConfig.configFile });
-		sources.push({
-			files: "dialex.config",
-			extensions: [
-				"ts",
-				"mts",
-				"cts",
-				"js",
-				"mjs",
-				"cjs",
-				"json",
-				""
-			]
-		}, {
-			files: "i18n.config",
-			extensions: [
-				"ts",
-				"mts",
-				"cts",
-				"js",
-				"mjs",
-				"cjs",
-				"json",
-				""
-			]
-		});
-		const result = loadConfigSync({
-			sources,
-			merge: false,
-			defaults: {},
-			cwd: root
-		});
-		if (result && result.config) loadedConfig = result.config;
+		const loaded = loadConfigObject(root, inlineConfig.configFile);
+		if (loaded) loadedConfig = loaded.config;
 	} catch {}
 	return {
 		...DEFAULT_CONFIG,
@@ -990,7 +1208,15 @@ const REGISTRY_ADAPTERS = [
 	"vue",
 	"web",
 	"h3",
-	"angular"
+	"angular",
+	"svelte",
+	"solid",
+	"preact",
+	"qwik",
+	"lit",
+	"hapi",
+	"adonis",
+	"trpc"
 ];
 /** Dependencies that tell which `dialexjs/*` entry points a project can import. */
 const ADAPTER_DEPENDENCIES = {
@@ -1011,6 +1237,17 @@ const ADAPTER_DEPENDENCIES = {
 	h3: ["h3"],
 	nitropack: ["h3"],
 	"@angular/core": ["angular"],
+	svelte: ["svelte"],
+	"solid-js": ["solid"],
+	preact: ["preact"],
+	"@builder.io/qwik": ["qwik"],
+	lit: ["lit"],
+	"@hapi/hapi": ["hapi"],
+	"@adonisjs/core": ["adonis"],
+	"@adonisjs/http-server": ["adonis"],
+	"@trpc/server": ["trpc"],
+	"react-native": ["react"],
+	expo: ["react"],
 	"react-router": ["web"],
 	"react-router-dom": ["web"],
 	"@remix-run/react": ["web"],
@@ -1041,9 +1278,9 @@ function detectAdapters(root) {
 * The `dialex-env.d.ts` a project should have: its path and contents, or `undefined` when there
 * are no dictionary files. Nothing is written.
 */
-function renderDts(root, files, locales, messageArguments = {}) {
+function renderDts(root, files, locales, messageArguments = {}, directory) {
 	if (files.length === 0) return void 0;
-	const dtsDir = fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root;
+	const dtsDir = directory ?? (fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root);
 	const imports = [];
 	const records = [];
 	files.forEach((file, index) => {
@@ -1226,9 +1463,9 @@ function splitLocales(df) {
 	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 {
+		const locale = propertyKeyName(prop);
+		const value = unwrapNode(prop.value);
+		if (locale === void 0 || !isObjectNode(value)) return {
 			ok: false,
 			reason: "a locale is not an object literal"
 		};
@@ -1253,8 +1490,10 @@ function splitLocales(df) {
 }
 //#endregion
 //#region src/utils/static-config.ts
+/** The names a config file can have, without extension, in order of preference. */
 const CONFIG_NAMES = ["dialex.config", "i18n.config"];
-const EXTENSIONS = [
+/** The extensions tried for each name, in order. */
+const CONFIG_EXTENSIONS = [
 	"ts",
 	"mts",
 	"cts",
@@ -1263,6 +1502,22 @@ const EXTENSIONS = [
 	"cjs",
 	"json"
 ];
+/** The keys of the config that tooling reads. */
+const CONFIG_KEYS = [
+	"defaultLocale",
+	"locales",
+	"include",
+	"exclude",
+	"output",
+	"fallbacks",
+	"prefixDefault",
+	"lazy",
+	"lint"
+];
+/** The paths `readStaticConfig` and `resolveConfig` try, in order, for a project root. */
+function configCandidates(root, configFile) {
+	return configFile ? [path.resolve(root, configFile)] : CONFIG_NAMES.flatMap((name) => CONFIG_EXTENSIONS.map((ext) => path.join(root, `${name}.${ext}`)));
+}
 const DEFAULT_STATIC_CONFIG = {
 	defaultLocale: "en",
 	locales: [],
@@ -1270,11 +1525,12 @@ const DEFAULT_STATIC_CONFIG = {
 	exclude: [],
 	fallbacks: {},
 	prefixDefault: true,
-	lazy: false
+	lazy: false,
+	lint: { rules: {} }
 };
 const NOT_LITERAL = Symbol("not literal");
 function literal(node) {
-	node = unwrap(node);
+	node = unwrapNode(node);
 	switch (node?.type) {
 		case "StringLiteral":
 		case "NumericLiteral":
@@ -1288,7 +1544,7 @@ function literal(node) {
 		case "ObjectExpression": {
 			const result = {};
 			for (const prop of node.properties) {
-				const key = keyName(prop);
+				const key = propertyKeyName(prop);
 				const value = key === void 0 ? NOT_LITERAL : literal(prop.value);
 				if (value === NOT_LITERAL) return NOT_LITERAL;
 				result[key] = value;
@@ -1300,12 +1556,36 @@ function literal(node) {
 }
 /** The object literal passed to `defineConfig({...})`, or exported directly. */
 function findConfigObject(declaration) {
-	const node = unwrap(declaration);
+	const node = unwrapNode(declaration);
 	if (node?.type === "CallExpression") return findConfigObject(node.arguments[0]);
-	return isObject(node) ? node : void 0;
+	return isObjectNode(node) ? node : void 0;
 }
 const isStringArray = (value) => Array.isArray(value) && value.every((v) => typeof v === "string");
-function apply(object, config, notes) {
+const LINT_LEVELS = [
+	"off",
+	"warn",
+	"error"
+];
+/** `lint: { rules: { code: "warn" | ["warn", {...}] } }`, or `undefined` when it is not that shape. */
+function lintRules(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const rules = value.rules;
+	if (rules === void 0) return {};
+	if (typeof rules !== "object" || rules === null || Array.isArray(rules)) return void 0;
+	const result = {};
+	for (const [code, setting] of Object.entries(rules)) {
+		const [level, options] = Array.isArray(setting) ? setting : [setting];
+		if (typeof level !== "string" || !LINT_LEVELS.includes(level)) return void 0;
+		if (options !== void 0 && (typeof options !== "object" || options === null)) return void 0;
+		result[code] = setting;
+	}
+	return result;
+}
+/**
+* Applies the values of a config object (read from a syntax tree or from a loaded module) over
+* `config`, with the same checks and notes either way.
+*/
+function applyConfigValues(object, config, notes) {
 	const accept = (key, valid, expected) => {
 		if (!(key in object)) return;
 		const value = object[key];
@@ -1316,25 +1596,33 @@ function apply(object, config, notes) {
 	accept("locales", isStringArray, "an array of string literals");
 	accept("include", (v) => typeof v === "string" || isStringArray(v), "a string or array of strings");
 	accept("exclude", isStringArray, "an array of string literals");
+	accept("output", (v) => typeof v === "string" && v !== "", "a string literal");
 	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" || v === "locale", "true, false or \"locale\"");
+	if ("lint" in object) {
+		const rules = lintRules(object.lint);
+		if (rules) config.lint = { rules };
+		else notes.push("\"lint\" could not be read statically (expected { rules: { code: \"off\" | \"warn\" | \"error\" | [level, options] } }).");
+	}
 }
 /** Reads a config file's source text. Exposed for tests and for unsaved buffers. */
 function parseStaticConfig(text, file = "dialex.config.ts") {
 	const notes = [];
 	const config = { ...DEFAULT_STATIC_CONFIG };
+	let opaque = false;
 	if (file.endsWith(".json")) {
 		try {
 			const data = JSON.parse(text);
-			if (data && typeof data === "object") apply(data, config, notes);
+			if (data && typeof data === "object") applyConfigValues(data, config, notes);
 		} catch (error) {
 			notes.push(`Could not parse ${path.basename(file)}: ${error.message}`);
 		}
 		return {
 			config,
 			file,
-			notes
+			notes,
+			opaque
 		};
 	}
 	try {
@@ -1343,22 +1631,15 @@ function parseStaticConfig(text, file = "dialex.config.ts") {
 		if (!object) notes.push(`${path.basename(file)} does not export a config object literal.`);
 		else {
 			const values = {};
-			for (const key of [
-				"defaultLocale",
-				"locales",
-				"include",
-				"exclude",
-				"fallbacks",
-				"prefixDefault",
-				"lazy"
-			]) {
-				const prop = findProp(object, key);
+			opaque = object.properties.some((p) => p.type === "SpreadElement" || p.type === "SpreadProperty" || p.computed === true);
+			for (const key of CONFIG_KEYS) {
+				const prop = findProperty(object, key);
 				if (!prop) continue;
 				const value = literal(prop.value);
 				if (value === NOT_LITERAL) notes.push(`"${key}" could not be read statically (not a literal).`);
 				else values[key] = value;
 			}
-			apply(values, config, notes);
+			applyConfigValues(values, config, notes);
 		}
 	} catch (error) {
 		notes.push(`Could not parse ${path.basename(file)}: ${error.message}`);
@@ -1366,16 +1647,17 @@ function parseStaticConfig(text, file = "dialex.config.ts") {
 	return {
 		config,
 		file,
-		notes
+		notes,
+		opaque
 	};
 }
 /** Reads `dialex.config.*` (or `i18n.config.*`) from `root`, or from `configFile` if given. */
 function readStaticConfig(root, configFile) {
-	const candidates = configFile ? [path.resolve(root, configFile)] : CONFIG_NAMES.flatMap((name) => EXTENSIONS.map((ext) => path.join(root, `${name}.${ext}`)));
-	for (const file of candidates) if (fs.existsSync(file)) return parseStaticConfig(fs.readFileSync(file, "utf-8"), file);
+	for (const file of configCandidates(root, configFile)) if (fs.existsSync(file)) return parseStaticConfig(fs.readFileSync(file, "utf-8"), file);
 	return {
 		config: { ...DEFAULT_STATIC_CONFIG },
-		notes: []
+		notes: [],
+		opaque: false
 	};
 }
 //#endregion
@@ -1408,7 +1690,15 @@ 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`. */
+/** A package in `extends` (`@adonisjs/tsconfig/tsconfig.app.json`), looked up from `dir` upwards. */
+function packageConfig(from, specifier) {
+	for (let dir = from;; dir = path.dirname(dir)) {
+		const found = configFile(path.join(dir, "node_modules", specifier));
+		if (found) return found;
+		if (path.dirname(dir) === dir) return void 0;
+	}
+}
+/** `moduleResolution` and `include` of a tsconfig, following `extends` (relative or a package). */
 function read(file, depth = 0) {
 	const result = { references: [] };
 	let json;
@@ -1418,8 +1708,12 @@ function read(file, depth = 0) {
 		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 parents = Array.isArray(json.extends) ? json.extends : [json.extends];
+	for (const extendsFrom of parents) {
+		if (typeof extendsFrom !== "string" || depth >= 5) continue;
+		const parent = extendsFrom.startsWith(".") ? configFile(path.resolve(dir, extendsFrom)) : packageConfig(dir, extendsFrom);
+		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;
@@ -1445,7 +1739,7 @@ function relativeImportExtension(root) {
 	return resolution === "node16" || resolution === "nodenext" ? ".js" : "";
 }
 //#endregion
-//#region src/commands/generate.ts
+//#region src/commands/generate/render.ts
 /** 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, "_");
@@ -1462,7 +1756,8 @@ function renderGenerated(root, options = {}) {
 	const config = options.static ? staticRead.config : resolveDialexConfig(root, inlineConfig);
 	const found = scanFiles(root, config.include || DEFAULT_CONFIG.include, { exclude: config.exclude }).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 outputOption = options.output ?? config.output;
+	const outputPath = outputOption ? path.resolve(root, outputOption) : 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")));
@@ -1552,18 +1847,70 @@ export const dialex = { dictionaries, config };
 export default dictionaries;
 `;
 	}
-	const dts = renderDts(root, files, locales, messageArguments(parsed, clientConfig.defaultLocale));
+	const dts = renderDts(root, files, locales, messageArguments(parsed, clientConfig.defaultLocale), outputOption ? outputDir : void 0);
 	return {
 		files,
 		outputPath,
 		content,
-		dtsPath: dts?.path ?? path.join(srcDir, "dialex-env.d.ts"),
+		dtsPath: dts?.path ?? path.join(outputOption ? outputDir : srcDir, "dialex-env.d.ts"),
 		dtsContent: dts?.content,
 		configFile: staticRead.file,
 		extraFiles,
 		notes
 	};
 }
+//#endregion
+//#region src/commands/generate/watch.ts
+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, log = (message) => logger.info(message)) {
+	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 gitIgnored = createGitignoreFilter(root);
+	const watcher = chokidar.watch(root, {
+		ignoreInitial: true,
+		ignored: (file) => WATCH_IGNORED.test(file) || gitIgnored(path.resolve(root, 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;
+		log(`[${event}] ${path.relative(root, file)} changed, regenerating...`);
+		trigger();
+	});
+	return watcher;
+}
+//#endregion
+//#region src/commands/generate/write.ts
 function writeIfChanged(file, content) {
 	if ((fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : "") === content) return;
 	fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -1591,6 +1938,8 @@ function generateDictionaries(root, options = {}) {
 		notes: rendered.notes
 	};
 }
+//#endregion
+//#region src/commands/generate/index.ts
 async function runGenerate(options = {}) {
 	const root = options.cwd || process.cwd();
 	const quiet = options.json === true;
@@ -1627,54 +1976,6 @@ async function runGenerate(options = {}) {
 		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, log = (message) => logger.info(message)) {
-	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 gitIgnored = createGitignoreFilter(root);
-	const watcher = chokidar.watch(root, {
-		ignoreInitial: true,
-		ignored: (file) => WATCH_IGNORED.test(file) || gitIgnored(path.resolve(root, 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;
-		log(`[${event}] ${path.relative(root, file)} changed, regenerating...`);
-		trigger();
-	});
-	return watcher;
-}
 //#endregion
 //#region src/utils/project.ts
 async function loadDictionaries(root, config) {
@@ -1729,6 +2030,6 @@ async function loadStaticProject(root, configFile) {
 /** `home` + `["nav", "about"]` -> `home.nav.about` */
 const toKey = (dictionary, keyPath) => [dictionary, ...keyPath].join(".");
 //#endregion
-export { scanFiles as A, locationOf as B, lockPath as C, BUILTIN_IGNORE as D, writeLock as E, getString as F, renderDictionaryFile as H, hasPath as I, listLeaves as L, copyLeaf as M, dictionaryLocation as N, SOURCE_BUILTIN_IGNORE as O, getLeafSource as P, listLocales as R, lockFor as S, record as T, saveDictionaryFile as U, parseDictionaryText as V, setString as W, relativeFile as _, renderGenerated as a, hashSource as b, DEFAULT_STATIC_CONFIG as c, resolveDialexConfig as d, logger as f, createAnalysisCache as g, clearGitignore as h, generateDictionaries as i, TODO_PREFIX as j, createGitignoreFilter as k, parseStaticConfig as l, analyzeProject as m, loadStaticProject as n, runGenerate as o, DEFAULT_SOURCE_GLOB as p, toKey as r, startGenerateWatcher as s, loadProject as t, readStaticConfig as u, scanReferences as v, readLock as w, isStale as x, LOCK_FILE as y, loadDictionaryFile as z };
+export { scanFiles as A, listLeaves as B, lockPath as C, BUILTIN_IGNORE as D, writeLock as E, locationOf as F, saveDictionaryFile as G, loadDictionaryFile as H, copyLeaf as I, TODO_PREFIX as K, setString as L, createAnalysisCache as M, dictionaryLocation as N, SOURCE_BUILTIN_IGNORE as O, getLeafSource as P, getString as R, lockFor as S, record as T, parseDictionaryText as U, listLocales as V, renderDictionaryFile as W, scanReferences as _, generateDictionaries as a, hashSource as b, DEFAULT_STATIC_CONFIG as c, resolveDialexConfig as d, logger as f, DEFAULT_SOURCE_GLOB as g, relativeFile as h, runGenerate as i, clearGitignore as j, createGitignoreFilter as k, parseStaticConfig as l, analyzeProjectSync as m, loadStaticProject as n, startGenerateWatcher as o, analyzeProject as p, toKey as r, renderGenerated as s, loadProject as t, readStaticConfig as u, scanText as v, readLock as w, isStale as x, LOCK_FILE as y, hasPath as z };
 
-//# sourceMappingURL=project-Dz0FbydQ.mjs.map
+//# sourceMappingURL=project-BTpZGNjh.mjs.map