@saykit/config 0.0.0-beta-20260309151609

package/dist/commands/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/commands/index.mjs

@@ -0,0 +1,579 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command, program } from "@commander-js/extra-typings";
+import { dirname, extname, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { err, ok } from "neverthrow";
+import picomatch from "picomatch";
+import * as z from "zod";
+import { access, glob, mkdir, readFile, rm, watch, writeFile } from "node:fs/promises";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { collectMessages, generateHash } from "@saykit/babel-plugin/core";
+
+//#region src/shapes.ts
+const Message = z.object({
+	message: z.string(),
+	translation: z.string().optional(),
+	id: z.string().optional(),
+	context: z.string().optional(),
+	comments: z.string().array(),
+	references: z.string().array()
+});
+const Formatter = z.object({
+	extension: z.templateLiteral([".", z.string()]).transform((v) => v.slice(1)),
+	parse: z.custom((v) => typeof v === "function"),
+	stringify: z.custom((v) => typeof v === "function")
+});
+async function tryImport(id) {
+	const require = createRequire(join(process.cwd(), "noop.js"));
+	try {
+		return ok(await import(pathToFileURL(require.resolve(id)).toString()));
+	} catch {
+		return err(`Cannot find package '${id}', required by saykit`);
+	}
+}
+const Bucket = z.object({
+	include: z.array(z.string()),
+	exclude: z.array(z.string()).optional(),
+	output: z.templateLiteral([
+		z.string(),
+		"{locale}",
+		z.string(),
+		".{extension}"
+	]),
+	formatter: Formatter.optional().transform(async (formatter, context) => {
+		if (formatter) return formatter;
+		const module = await tryImport("@saykit/format-po");
+		if (module.isErr()) {
+			context.addIssue(module.error);
+			return z.NEVER;
+		}
+		formatter = module.value.default();
+		const result = Formatter.safeParse(formatter);
+		if (result.error) {
+			for (const issue of result.error.issues) context.addIssue({ ...issue });
+			return z.NEVER;
+		}
+		return result.data;
+	})
+}).transform((v) => ({
+	...v,
+	match: picomatch(v.include, { ignore: v.exclude })
+}));
+const Configuration = z.object({
+	sourceLocale: z.string(),
+	locales: z.tuple([z.string()], z.string()),
+	fallbackLocales: z.record(z.string(), z.array(z.string())).optional(),
+	buckets: z.array(Bucket)
+}).refine((c) => c.sourceLocale === c.locales[0], "sourceLocale must be the same as the first locale");
+
+//#endregion
+//#region src/features/loader/explorer.ts
+function getFilesToTry(name) {
+	return [
+		`.${name}rc`,
+		`.${name}rc.json`,
+		`.${name}rc.yaml`,
+		`.${name}rc.yml`,
+		`.${name}rc.js`,
+		`.${name}rc.cjs`,
+		`.${name}rc.mjs`,
+		`.${name}rc.ts`,
+		`.${name}rc.mts`,
+		`.${name}rc.cts`,
+		`${name}.config.json`,
+		`${name}.config.js`,
+		`${name}.config.cjs`,
+		`${name}.config.mjs`,
+		`${name}.config.ts`,
+		`${name}.config.mts`,
+		`${name}.config.cts`,
+		"package.json"
+	];
+}
+async function findConfigFile(moduleName, projectDir) {
+	for (const fileName of getFilesToTry(moduleName)) try {
+		const id = join(projectDir, fileName);
+		await access(id);
+		return {
+			id,
+			content: await readFile(id, "utf8")
+		};
+	} catch {}
+	return null;
+}
+
+//#endregion
+//#region src/features/loader/loaders.ts
+const js = async (path, _content) => {
+	try {
+		const { href } = pathToFileURL(path);
+		return (await import(href)).default;
+	} catch (importError) {
+		try {
+			const require = globalThis.require ?? createRequire(path);
+			const module = require(path);
+			delete require.cache[require.resolve(path)];
+			return module?.default ?? module;
+		} catch (requireError) {
+			throw new Error("Failed to import module", { cause: [importError, requireError] });
+		}
+	}
+};
+const json = async (_path, content) => {
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		throw new Error("Failed to parse JSON", { cause: error });
+	}
+};
+let YAML;
+(function(_YAML) {
+	function parse(text) {
+		const lines = text.split(/\r?\n/).filter((l) => l.trim() !== "").map((l) => [l.match(/^\s*/)[0].length, l]);
+		const root = {};
+		const stack = [{
+			indent: -1,
+			container: root
+		}];
+		function parseValue(value, fallback) {
+			if (value === "true") return true;
+			if (value === "false") return false;
+			if (!Number.isNaN(Number(value)) && value !== "") return Number(value);
+			if (value.startsWith("[") && value.endsWith("]")) return value.slice(1, -1).split(",").map((e) => parseValue(e.trim()));
+			return value || fallback || value;
+		}
+		for (let [indent, line] of lines) {
+			const parent = stack.at(-1);
+			while (stack.length > 1 && indent <= parent.indent) stack.pop();
+			if (line.startsWith("- ")) {
+				line = line.slice(2).trim();
+				let value;
+				if (line === "") value = {};
+				else if (line.includes(":")) {
+					const [k, ...r] = line.split(":");
+					value = { [k.trim()]: parseValue(r.join(":").trim()) };
+				} else value = parseValue(line);
+				if (!Array.isArray(parent.container)) {
+					const upper = stack.at(-2);
+					if (!Array.isArray(upper.container)) {
+						for (const key in upper.container) if (upper.container[key] === parent.container) {
+							upper.container[key] = [value];
+							stack.push({
+								indent,
+								container: upper.container[key]
+							});
+							break;
+						}
+					} else throw new Error("Invalid YAML: expected parent object for array conversion");
+				} else parent.container.push(value);
+				if (typeof value === "object" && value && !Array.isArray(value)) stack.push({
+					indent,
+					container: value
+				});
+			} else {
+				const [key, ...rest] = line.split(":");
+				const value = parseValue(rest.join(":").trim(), {});
+				if (!Array.isArray(parent.container)) parent.container[key.trim()] = value;
+				else throw new Error("Invalid YAML: cannot assign key to non-object");
+				if (typeof value === "object" && value && !Array.isArray(value)) stack.push({
+					indent,
+					container: value
+				});
+			}
+		}
+		return root;
+	}
+	_YAML.parse = parse;
+})(YAML || (YAML = {}));
+const yaml = async (_path, content) => {
+	try {
+		return YAML.parse(content);
+	} catch (error) {
+		throw new Error("Failed to parse YAML", { cause: error });
+	}
+};
+const ts = async (path, content) => {
+	const ts = await import("typescript");
+	const outputPath = `${path}.${Date.now()}.js`;
+	try {
+		const tsConfigPath = ts.findConfigFile(dirname(path), ts.sys.fileExists) || "tsconfig.json";
+		const { config: tsConfig, error } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+		if (error) throw error;
+		tsConfig.compilerOptions = {
+			...tsConfig.compilerOptions,
+			module: ts.ModuleKind.ES2022,
+			moduleResolution: ts.ModuleResolutionKind.Bundler,
+			target: ts.ScriptTarget.ES2022,
+			noEmit: false
+		};
+		const transpiledContent = ts.transpileModule(content, tsConfig).outputText;
+		await writeFile(outputPath, transpiledContent);
+		return await js(outputPath, transpiledContent);
+	} catch (error) {
+		throw new Error("Failed to import module", { cause: error });
+	} finally {
+		if (ts.sys.fileExists(outputPath)) await rm(outputPath);
+	}
+};
+const detect = async (path, content) => {
+	try {
+		return await yaml(path, content);
+	} catch {
+		try {
+			return await json(path, content);
+		} catch {
+			return;
+		}
+	}
+};
+var loaders_default = Object.freeze({
+	".js": js,
+	".mjs": js,
+	".cjs": js,
+	".json": json,
+	".yaml": yaml,
+	".yml": yaml,
+	"": detect,
+	".ts": ts,
+	".mts": ts,
+	".cts": ts
+});
+
+//#endregion
+//#region src/features/loader/resolve.ts
+async function useConfig(name = "saykit") {
+	const file = await findConfigFile(name, process.cwd());
+	if (!file) throw new Error(`Could not find config file for "${name}"`);
+	const ext = extname(file.id).toLowerCase();
+	let config = await (ext in loaders_default ? loaders_default[ext] : loaders_default[""])(file.id, file.content);
+	if (!config || typeof config !== "object") throw new Error(`Invalid config file for "${name}"`);
+	if (config && typeof config === "object" && "saykit" in config) config = config.saykit;
+	const result = await Configuration.safeParseAsync(config);
+	if (result.error) throw new Error(`Invalid config file for "${name}"`, { cause: result.error });
+	return result.data;
+}
+
+//#endregion
+//#region src/features/logger.ts
+const RESET = "\x1B[0m";
+const DIM = "\x1B[2m";
+const BRIGHT = "\x1B[1m";
+const RED = "\x1B[31m";
+const GREEN = "\x1B[32m";
+const YELLOW = "\x1B[33m";
+const BLUE = "\x1B[34m";
+var Logger = class {
+	#quiet;
+	#verbose;
+	constructor(options = {}) {
+		this.#quiet = options.quiet ?? false;
+		this.#verbose = options.verbose ?? false;
+	}
+	log(...args) {
+		if (!this.#quiet) console.log(...args);
+	}
+	info(...args) {
+		this.log(`${BLUE}🛈${RESET}`, ...args);
+	}
+	warn(...args) {
+		this.log(`${YELLOW}⚠${RESET}`, ...args);
+	}
+	error(...args) {
+		this.log(`${RED}✖${RESET}`, ...args);
+	}
+	success(...args) {
+		this.log(`${GREEN}✔${RESET}`, ...args);
+	}
+	header(message) {
+		this.log(`${BRIGHT}${message}${RESET}`);
+	}
+	step(message) {
+		if (this.#verbose) this.log(` ${DIM}→ ${message}${RESET}`);
+	}
+};
+const loggerStorage = new AsyncLocalStorage({ defaultValue: new Logger() });
+
+//#endregion
+//#region src/features/extract.ts
+async function extractMessages(path) {
+	return collectMessages(path, await readFile(path, "utf8").catch(() => "")).map((m) => ({
+		message: m.toICUString(),
+		translation: m.toICUString(),
+		id: m.descriptor.id,
+		context: m.descriptor.context,
+		comments: m.comments,
+		references: m.references.map((r) => relative(process.cwd(), r).replaceAll("\\", "/"))
+	}));
+}
+function mergeUnique(...items) {
+	return Array.from(new Set(items.flat()));
+}
+function mergeMessages(messages) {
+	const mergedMessages = messages.reduce((map, message) => {
+		const key = message.id ?? generateHash(message.message, message.context);
+		const existing = map.get(key) ?? message;
+		map.set(key, {
+			...existing,
+			comments: mergeUnique(...existing.comments, ...message.comments),
+			references: mergeUnique(...existing.references, ...message.references)
+		});
+		return map;
+	}, /* @__PURE__ */ new Map());
+	return Array.from(mergedMessages.values());
+}
+function reconcileMessages(existingMessages, newMessages) {
+	const existingMessagesMap = existingMessages.reduce((map, message) => {
+		const key = message.id ?? generateHash(message.message, message.context);
+		map.set(key, message);
+		return map;
+	}, /* @__PURE__ */ new Map());
+	const updatedMessagesMap = newMessages.reduce((map, message) => {
+		const key = message.id ?? generateHash(message.message, message.context);
+		const existingMessage = existingMessagesMap.get(key);
+		map.set(key, {
+			message: message.message,
+			translation: void 0,
+			...existingMessage,
+			id: message.id,
+			context: message.context,
+			comments: message.comments,
+			references: message.references
+		});
+		return map;
+	}, /* @__PURE__ */ new Map());
+	return Array.from(updatedMessagesMap.values());
+}
+function expandOutputPath(bucket, locale, extension = bucket.formatter.extension) {
+	return resolve(bucket.output.replaceAll("{locale}", locale).replaceAll("{extension}", extension));
+}
+async function readMessagesFromDisk(bucket, locale, path = expandOutputPath(bucket, locale)) {
+	const content = await readFile(path, "utf8").catch(() => "");
+	if (!content) return [];
+	return await bucket.formatter.parse(content, { locale });
+}
+async function writeMessagesToDisk(bucket, locale, messages, path = expandOutputPath(bucket, locale)) {
+	const content = await bucket.formatter.stringify(messages, { locale });
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, content);
+}
+
+//#endregion
+//#region src/features/compile.ts
+async function hydrateTranslations(cache, config, bucket, locale, messages) {
+	if (cache.has(locale)) return cache.get(locale);
+	const translations = await applyFallbackTranslations(cache, config, bucket, locale, messages);
+	cache.set(locale, translations);
+	return translations;
+}
+function getFallbackChain(config, locale) {
+	return [...config.fallbackLocales?.[locale] ?? [], config.sourceLocale];
+}
+async function applyFallbackTranslations(cache, config, bucket, locale, messages) {
+	const fallbacks = getFallbackChain(config, locale);
+	const translations = {};
+	for (const message of messages) {
+		const key = message.id ?? generateHash(message.message, message.context);
+		if (message.translation) {
+			translations[key] = message.translation;
+			continue;
+		}
+		for (const fallback of fallbacks) {
+			const fallbackMessages = await hydrateTranslations(cache, config, bucket, fallback, messages);
+			if (fallbackMessages[key]) {
+				translations[key] = fallbackMessages[key];
+				break;
+			}
+		}
+	}
+	return translations;
+}
+async function writeTranslationsToDisk(bucket, locale, translations, path = expandOutputPath(bucket, locale, "json")) {
+	const content = JSON.stringify(translations, null, 2);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, content);
+}
+
+//#endregion
+//#region src/features/watch.ts
+/**
+* Expand a buckets include and exclude patterns into a flat list of file paths.
+*/
+async function globBucket(bucket) {
+	const paths = [];
+	for await (const file of glob(bucket.include, {
+		exclude: bucket.exclude,
+		withFileTypes: true
+	})) if (file.isFile()) paths.push(join(file.parentPath, file.name));
+	return paths;
+}
+/**
+* Watches a path for changes, emitting a debounced event every set delay.
+*
+* Unlike Node's native `fs.watch` method, this:
+*  - coalesces rapid consecutive events per file
+*  - emits only the final event after `delay` ms of inactivity
+*  - deduplicates events by filename
+*/
+async function* watchDebounced(path, options, delay = 300) {
+	const timers = /* @__PURE__ */ new Map();
+	const queue = /* @__PURE__ */ new Map();
+	const resolvers = /* @__PURE__ */ new Map();
+	(async () => {
+		for await (const event of watch(path, options)) {
+			const key = event.filename ?? "__unknown__";
+			if (timers.has(key)) clearTimeout(timers.get(key));
+			if (!queue.has(key)) queue.set(key, new Promise((r) => resolvers.set(key, r)));
+			timers.set(key, setTimeout(() => {
+				resolvers.get(key)?.(event);
+				timers.delete(key);
+				resolvers.delete(key);
+			}, delay));
+		}
+	})();
+	while (true) if (queue.size) {
+		const next = await Promise.race(queue.values());
+		queue.delete(next.filename ?? "__unknown__");
+		yield next;
+	} else await new Promise((r) => setTimeout(r, 10));
+}
+
+//#endregion
+//#region src/features/worker.ts
+function normalisePath(path) {
+	return relative(process.cwd(), path).replaceAll("\\", "/");
+}
+var BucketWorker = class {
+	config;
+	bucket;
+	logger;
+	constructor(config, bucket, logger) {
+		this.config = config;
+		this.bucket = bucket;
+		this.logger = logger;
+	}
+};
+var BucketExtractWorker = class extends BucketWorker {
+	index = /* @__PURE__ */ new Map();
+	get messages() {
+		return Array.from(this.index.values()).flat();
+	}
+	async indexPath(path) {
+		const rp = normalisePath(path);
+		this.logger.step(`Processing ${rp}`);
+		const messages = await extractMessages(path);
+		if (!messages.length) return false;
+		this.index.set(path, messages);
+		this.logger.step(`Found ${messages.length} messages(s) in ${rp}`);
+		return true;
+	}
+	async scanAll() {
+		this.logger.info(`Scanning bucket: ${this.bucket.include}`);
+		const paths = await globBucket(this.bucket);
+		this.logger.step(`Found ${paths.length} file(s)`);
+		await Promise.all(paths.map((p) => this.indexPath(p)));
+		this.logger.info(`Total extracted messages: ${this.messages.length}`);
+	}
+	async writeAll() {
+		const newMessages = mergeMessages(this.messages);
+		this.logger.info(`Writing ${newMessages.length} messages to locales`);
+		for (const locale of this.config.locales) {
+			this.logger.step(`Writing locale file for ${locale} to disk`);
+			const existingMessages = await readMessagesFromDisk(this.bucket, locale);
+			const updatedMessages = locale === this.config.sourceLocale ? newMessages : reconcileMessages(existingMessages, newMessages);
+			await writeMessagesToDisk(this.bucket, locale, updatedMessages);
+		}
+		this.logger.success(`Extraction complete for bucket: ${this.bucket.include}`);
+	}
+	async updatePath(path) {
+		const changed = await this.indexPath(path);
+		if (changed) await this.writeAll();
+		return changed;
+	}
+};
+var BucketCompileWorker = class extends BucketWorker {
+	cache = /* @__PURE__ */ new Map();
+	async compileAll() {
+		this.logger.info(`Compiling bucket: ${this.bucket.include}`);
+		for (const locale of this.config.locales) await this.compileLocale(locale);
+		this.logger.success(`Compilation complete for bucket: ${this.bucket.include}`);
+	}
+	async compileLocale(locale) {
+		this.logger.step(`Compiling locale: ${locale}`);
+		const messages = await readMessagesFromDisk(this.bucket, locale);
+		const translations = await hydrateTranslations(this.cache, this.config, this.bucket, locale, messages);
+		this.logger.step(`Writing runtime file for ${locale}`);
+		await writeTranslationsToDisk(this.bucket, locale, translations);
+	}
+};
+var BucketBuildWorker = class extends BucketWorker {
+	extract;
+	compile;
+	constructor(config, bucket, logger) {
+		super(config, bucket, logger);
+		this.extract = new BucketExtractWorker(config, bucket, logger);
+		this.compile = new BucketCompileWorker(config, bucket, logger);
+	}
+	async buildAll() {
+		await this.extract.scanAll();
+		await this.extract.writeAll();
+		await this.compile.compileAll();
+	}
+	async watch() {
+		this.logger.header(`👀 Watching bucket for changes: ${this.bucket.include}`);
+		for await (const event of watchDebounced(".", { recursive: true })) {
+			if (!event.filename || !this.bucket.match(event.filename)) continue;
+			const filePath = join(process.cwd(), event.filename);
+			if (await this.extract.updatePath(filePath)) {
+				this.logger.info(`Recompiling due to changes in ${normalisePath(filePath)}`);
+				await this.compile.compileAll();
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/commands/build.ts
+var build_default = new Command().name("build").description("").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
+	const config = await useConfig("saykit");
+	const logger = new Logger(options);
+	logger.header("🏗 Building Messages");
+	const tasks = config.buckets.map(async (bucket) => {
+		await new BucketBuildWorker(config, bucket, logger).buildAll();
+	});
+	await Promise.allSettled(tasks);
+});
+
+//#endregion
+//#region src/commands/compile.ts
+var compile_default = new Command("compile").description("Compile translations into runtime-ready locale files").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
+	const config = await useConfig("saykit");
+	const logger = new Logger(options);
+	logger.header("🛠 Compiling Translations");
+	const tasks = config.buckets.map(async (bucket) => {
+		await new BucketCompileWorker(config, bucket, logger).compileAll();
+	});
+	await Promise.allSettled(tasks);
+});
+
+//#endregion
+//#region src/commands/extract.ts
+var extract_default = new Command("extract").description("Extract messages from source files").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
+	const config = await useConfig("saykit");
+	const logger = new Logger(options);
+	logger.header("🛠 Extracting Messages");
+	const tasks = config.buckets.map(async (bucket) => {
+		const worker = new BucketExtractWorker(config, bucket, logger);
+		await worker.scanAll();
+		await worker.writeAll();
+	});
+	await Promise.allSettled(tasks);
+});
+
+//#endregion
+//#region src/commands/index.ts
+program.name("saykit").helpOption("-h, --help", "Display help for command").helpCommand("help [command]", "Display help for command").addCommand(extract_default).addCommand(compile_default).addCommand(build_default).parse();
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.mjs.map

package/dist/index.d.mts

@@ -0,0 +1,163 @@
+import picomatch from "picomatch";
+import * as z from "zod";
+import { input } from "zod";
+
+//#region src/shapes.d.ts
+declare const Message: z.ZodObject<{
+  message: z.ZodString;
+  translation: z.ZodOptional<z.ZodString>;
+  id: z.ZodOptional<z.ZodString>;
+  context: z.ZodOptional<z.ZodString>;
+  comments: z.ZodArray<z.ZodString>;
+  references: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type Message = z.infer<typeof Message>;
+declare const Formatter: z.ZodObject<{
+  extension: z.ZodPipe<z.ZodTemplateLiteral<`.${string}`>, z.ZodTransform<string, `.${string}`>>;
+  parse: z.ZodCustom<(content: string, context: {
+    locale: string;
+  }) => Promise<Message[]>, (content: string, context: {
+    locale: string;
+  }) => Promise<Message[]>>;
+  stringify: z.ZodCustom<(messages: Message[], context: {
+    locale: string;
+  }) => Promise<string>, (messages: Message[], context: {
+    locale: string;
+  }) => Promise<string>>;
+}, z.core.$strip>;
+type Formatter = z.infer<typeof Formatter>;
+declare const Bucket: z.ZodPipe<z.ZodObject<{
+  include: z.ZodArray<z.ZodString>;
+  exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  output: z.ZodTemplateLiteral<`${string}{locale}${string}.{extension}`>;
+  formatter: z.ZodPipe<z.ZodOptional<z.ZodObject<{
+    extension: z.ZodPipe<z.ZodTemplateLiteral<`.${string}`>, z.ZodTransform<string, `.${string}`>>;
+    parse: z.ZodCustom<(content: string, context: {
+      locale: string;
+    }) => Promise<Message[]>, (content: string, context: {
+      locale: string;
+    }) => Promise<Message[]>>;
+    stringify: z.ZodCustom<(messages: Message[], context: {
+      locale: string;
+    }) => Promise<string>, (messages: Message[], context: {
+      locale: string;
+    }) => Promise<string>>;
+  }, z.core.$strip>>, z.ZodTransform<{
+    extension: string;
+    parse: (content: string, context: {
+      locale: string;
+    }) => Promise<Message[]>;
+    stringify: (messages: Message[], context: {
+      locale: string;
+    }) => Promise<string>;
+  }, {
+    extension: string;
+    parse: (content: string, context: {
+      locale: string;
+    }) => Promise<Message[]>;
+    stringify: (messages: Message[], context: {
+      locale: string;
+    }) => Promise<string>;
+  } | undefined>>;
+}, z.core.$strip>, z.ZodTransform<{
+  match: picomatch.Matcher;
+  include: string[];
+  output: `${string}{locale}${string}.{extension}`;
+  formatter: {
+    extension: string;
+    parse: (content: string, context: {
+      locale: string;
+    }) => Promise<Message[]>;
+    stringify: (messages: Message[], context: {
+      locale: string;
+    }) => Promise<string>;
+  };
+  exclude?: string[] | undefined;
+}, {
+  include: string[];
+  output: `${string}{locale}${string}.{extension}`;
+  formatter: {
+    extension: string;
+    parse: (content: string, context: {
+      locale: string;
+    }) => Promise<Message[]>;
+    stringify: (messages: Message[], context: {
+      locale: string;
+    }) => Promise<string>;
+  };
+  exclude?: string[] | undefined;
+}>>;
+type Bucket = z.infer<typeof Bucket>;
+declare const Configuration: z.ZodObject<{
+  sourceLocale: z.ZodString;
+  locales: z.ZodTuple<[z.ZodString], z.ZodString>;
+  fallbackLocales: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+  buckets: z.ZodArray<z.ZodPipe<z.ZodObject<{
+    include: z.ZodArray<z.ZodString>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    output: z.ZodTemplateLiteral<`${string}{locale}${string}.{extension}`>;
+    formatter: z.ZodPipe<z.ZodOptional<z.ZodObject<{
+      extension: z.ZodPipe<z.ZodTemplateLiteral<`.${string}`>, z.ZodTransform<string, `.${string}`>>;
+      parse: z.ZodCustom<(content: string, context: {
+        locale: string;
+      }) => Promise<Message[]>, (content: string, context: {
+        locale: string;
+      }) => Promise<Message[]>>;
+      stringify: z.ZodCustom<(messages: Message[], context: {
+        locale: string;
+      }) => Promise<string>, (messages: Message[], context: {
+        locale: string;
+      }) => Promise<string>>;
+    }, z.core.$strip>>, z.ZodTransform<{
+      extension: string;
+      parse: (content: string, context: {
+        locale: string;
+      }) => Promise<Message[]>;
+      stringify: (messages: Message[], context: {
+        locale: string;
+      }) => Promise<string>;
+    }, {
+      extension: string;
+      parse: (content: string, context: {
+        locale: string;
+      }) => Promise<Message[]>;
+      stringify: (messages: Message[], context: {
+        locale: string;
+      }) => Promise<string>;
+    } | undefined>>;
+  }, z.core.$strip>, z.ZodTransform<{
+    match: picomatch.Matcher;
+    include: string[];
+    output: `${string}{locale}${string}.{extension}`;
+    formatter: {
+      extension: string;
+      parse: (content: string, context: {
+        locale: string;
+      }) => Promise<Message[]>;
+      stringify: (messages: Message[], context: {
+        locale: string;
+      }) => Promise<string>;
+    };
+    exclude?: string[] | undefined;
+  }, {
+    include: string[];
+    output: `${string}{locale}${string}.{extension}`;
+    formatter: {
+      extension: string;
+      parse: (content: string, context: {
+        locale: string;
+      }) => Promise<Message[]>;
+      stringify: (messages: Message[], context: {
+        locale: string;
+      }) => Promise<string>;
+    };
+    exclude?: string[] | undefined;
+  }>>>;
+}, z.core.$strip>;
+type Configuration = z.infer<typeof Configuration>;
+//#endregion
+//#region src/define.d.ts
+declare function defineConfig<C extends input<typeof Configuration>>(config: C): C;
+//#endregion
+export { Bucket, Configuration, Formatter, Message, defineConfig };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,8 @@
+//#region src/define.ts
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+export { defineConfig };
+//# sourceMappingURL=index.mjs.map

package/dist/schema.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "sourceLocale": {
+      "type": "string"
+    },
+    "locales": {
+      "type": "array",
+      "items": [
+        {
+          "type": "string"
+        }
+      ],
+      "additionalItems": {
+        "type": "string"
+      }
+    },
+    "fallbackLocales": {
+      "type": "object",
+      "propertyNames": {
+        "type": "string"
+      },
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "buckets": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "include": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "exclude": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "output": {
+            "type": "string",
+            "pattern": "^[\\s\\S]{0,}\\{locale\\}[\\s\\S]{0,}\\.\\{extension\\}$"
+          },
+          "formatter": {
+            "type": "null",
+            "properties": {
+              "extension": {
+                "type": "null",
+                "pattern": "^\\.[\\s\\S]{0,}$"
+              },
+              "parse": {
+                "type": "null"
+              },
+              "stringify": {
+                "type": "null"
+              }
+            },
+            "required": [
+              "extension",
+              "parse",
+              "stringify"
+            ]
+          }
+        },
+        "required": [
+          "include",
+          "output"
+        ]
+      }
+    }
+  },
+  "required": [
+    "sourceLocale",
+    "locales",
+    "buckets"
+  ]
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@saykit/config",
+  "version": "0.0.0-beta-20260309151609",
+  "description": "CLI and configuration tooling for saykit",
+  "keywords": [
+    "cli",
+    "config",
+    "i18n",
+    "saykit"
+  ],
+  "homepage": "https://github.com/k0d13/saykit#readme",
+  "bugs": {
+    "url": "https://github.com/k0d13/saykit/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/k0d13/saykit.git",
+    "directory": "packages/config"
+  },
+  "bin": {
+    "saykit": "./dist/commands/index.mjs"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@commander-js/extra-typings": "^14.0.0",
+    "commander": "^14.0.3",
+    "neverthrow": "^8.2.0",
+    "picomatch": "^4.0.3",
+    "zod": "^4.3.6",
+    "@saykit/babel-plugin": "0.0.0-beta-20260309151609"
+  },
+  "devDependencies": {
+    "@types/picomatch": "^4.0.2",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "typescript": "*"
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "build": "tsdown"
+  }
+}