@contentrain/query 3.2.0 → 5.0.0

package/dist/generate-CPKYh6ZU.cjs

@@ -0,0 +1,858 @@
+let node_path = require("node:path");
+let node_fs_promises = require("node:fs/promises");
+//#region src/generator/utils.ts
+async function readJson(filePath) {
+	try {
+		const raw = await (0, node_fs_promises.readFile)(filePath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+async function readDir(dirPath) {
+	try {
+		return await (0, node_fs_promises.readdir)(dirPath);
+	} catch {
+		return [];
+	}
+}
+async function readText(filePath) {
+	try {
+		return await (0, node_fs_promises.readFile)(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+async function writeText(filePath, content) {
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(filePath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(filePath, content, "utf-8");
+}
+function contentrainDir(projectRoot) {
+	return (0, node_path.join)(projectRoot, ".contentrain");
+}
+//#endregion
+//#region src/generator/config-reader.ts
+async function readProjectManifest(projectRoot) {
+	const crDir = contentrainDir(projectRoot);
+	const rawConfig = await readJson((0, node_path.join)(crDir, "config.json"));
+	const config = {
+		version: rawConfig?.version ?? 1,
+		stack: rawConfig?.stack ?? "other",
+		workflow: rawConfig?.workflow ?? "auto-merge",
+		locales: {
+			default: rawConfig?.locales?.default ?? "en",
+			supported: rawConfig?.locales?.supported ?? [rawConfig?.locales?.default ?? "en"]
+		},
+		domains: rawConfig?.domains ?? [],
+		repository: rawConfig?.repository,
+		assets_path: rawConfig?.assets_path,
+		branchRetention: rawConfig?.branchRetention
+	};
+	const modelsDir = (0, node_path.join)(crDir, "models");
+	const modelFiles = (await readDir(modelsDir)).filter((f) => f.endsWith(".json"));
+	const models = (await Promise.all(modelFiles.map((file) => readJson((0, node_path.join)(modelsDir, file))))).filter((m) => m != null && Boolean(m.id)).toSorted((a, b) => a.id.localeCompare(b.id, "en"));
+	return {
+		config,
+		models,
+		contentFiles: (await Promise.all(models.map((model) => mapContentFiles(projectRoot, model, config)))).flat()
+	};
+}
+function getContentDir(projectRoot, model) {
+	if (model.content_path) return (0, node_path.join)(projectRoot, model.content_path);
+	return (0, node_path.join)(contentrainDir(projectRoot), "content", model.domain, model.id);
+}
+function getLocaleStrategy(model) {
+	return model.locale_strategy ?? "file";
+}
+function jsonFilePath(dir, model, locale) {
+	switch (getLocaleStrategy(model)) {
+		case "suffix": return (0, node_path.join)(dir, `${model.id}.${locale}.json`);
+		case "directory": return (0, node_path.join)(dir, locale, `${model.id}.json`);
+		case "none": return (0, node_path.join)(dir, `${model.id}.json`);
+		default: return (0, node_path.join)(dir, `${locale}.json`);
+	}
+}
+async function mapContentFiles(projectRoot, model, config) {
+	const dir = getContentDir(projectRoot, model);
+	if (model.kind === "document") return mapDocumentFiles(dir, model, config);
+	if (model.i18n) return (await Promise.all(config.locales.supported.map(async (locale) => {
+		const filePath = jsonFilePath(dir, model, locale);
+		if (await readJson(filePath) === null) return null;
+		return {
+			modelId: model.id,
+			locale,
+			filePath,
+			kind: model.kind
+		};
+	}))).filter(Boolean);
+	const filePath = (0, node_path.join)(dir, "data.json");
+	if (await readJson(filePath) === null) return [];
+	return [{
+		modelId: model.id,
+		locale: null,
+		filePath,
+		kind: model.kind
+	}];
+}
+async function mapDocumentFiles(dir, model, config) {
+	const strategy = getLocaleStrategy(model);
+	if (!model.i18n) return (await readDir(dir)).filter((f) => f.endsWith(".md")).map((f) => ({
+		modelId: model.id,
+		locale: null,
+		filePath: (0, node_path.join)(dir, f),
+		kind: "document",
+		slug: f.replace(".md", "")
+	}));
+	return (await Promise.all(config.locales.supported.map((locale) => mapDocumentLocale(dir, model, locale, strategy)))).flat();
+}
+async function mapDocumentLocale(dir, model, locale, strategy) {
+	if (strategy === "file") {
+		const entries = await readDir(dir);
+		return (await Promise.all(entries.map(async (entry) => {
+			const filePath = (0, node_path.join)(dir, entry, `${locale}.md`);
+			if (await readText(filePath) === null) return null;
+			return {
+				modelId: model.id,
+				locale,
+				filePath,
+				kind: "document",
+				slug: entry
+			};
+		}))).filter(Boolean);
+	}
+	if (strategy === "directory") {
+		const localeDir = (0, node_path.join)(dir, locale);
+		return (await readDir(localeDir)).filter((f) => f.endsWith(".md")).map((f) => ({
+			modelId: model.id,
+			locale,
+			filePath: (0, node_path.join)(localeDir, f),
+			kind: "document",
+			slug: f.replace(".md", "")
+		}));
+	}
+	if (strategy === "suffix") {
+		const suffix = `.${locale}.md`;
+		return (await readDir(dir)).filter((f) => f.endsWith(suffix)).map((f) => ({
+			modelId: model.id,
+			locale,
+			filePath: (0, node_path.join)(dir, f),
+			kind: "document",
+			slug: f.slice(0, -suffix.length)
+		}));
+	}
+	return [];
+}
+//#endregion
+//#region src/generator/type-emitter.ts
+function emitTypes(models) {
+	const lines = [
+		"/* eslint-disable */",
+		"/* oxlint-disable */",
+		"// Auto-generated by @contentrain/query — do not edit manually",
+		"// Re-generate with: npx contentrain-query generate",
+		"",
+		"export type ContentStatus = 'draft' | 'published' | 'in_review' | 'rejected' | 'archived'",
+		""
+	];
+	for (const model of models) {
+		if (model.kind === "dictionary") lines.push(`export type ${kebabToPascal(model.id)} = Record<string, string>`);
+		else {
+			lines.push(`export interface ${kebabToPascal(model.id)} {`);
+			if (model.kind === "collection") lines.push("  id: string");
+			if (model.kind === "document") {
+				lines.push("  slug: string");
+				lines.push("  content: string");
+			}
+			if (model.fields) for (const [name, field] of Object.entries(model.fields)) {
+				const tsType = fieldToTS(field);
+				const optional = field.required ? "" : "?";
+				lines.push(`  ${name}${optional}: ${tsType}`);
+			}
+			lines.push("}");
+		}
+		lines.push("");
+	}
+	lines.push(`export interface QueryBuilder<T> {
+  locale(lang: string): QueryBuilder<T>
+  where<K extends keyof T>(field: K, value: T[K]): QueryBuilder<T>
+  sort<K extends keyof T>(field: K, order?: 'asc' | 'desc'): QueryBuilder<T>
+  limit(n: number): QueryBuilder<T>
+  offset(n: number): QueryBuilder<T>
+  include(...fields: string[]): QueryBuilder<T>
+  first(): T | undefined
+  all(): T[]
+}`);
+	lines.push("");
+	lines.push(`export interface SingletonAccessor<T> {
+  locale(lang: string): SingletonAccessor<T>
+  include(...fields: string[]): SingletonAccessor<T>
+  get(): T
+}`);
+	lines.push("");
+	lines.push(`export interface DictionaryAccessor {
+  locale(lang: string): DictionaryAccessor
+  get(): Record<string, string>
+  get(key: string): string | undefined
+  get(key: string, params: Record<string, string | number>): string
+}`);
+	lines.push("");
+	lines.push(`export interface DocumentQuery<T> {
+  locale(lang: string): DocumentQuery<T>
+  where<K extends keyof T>(field: K, value: T[K]): DocumentQuery<T>
+  include(...fields: string[]): DocumentQuery<T>
+  bySlug(slug: string): T | undefined
+  first(): T | undefined
+  all(): T[]
+}`);
+	lines.push("");
+	const collections = models.filter((m) => m.kind === "collection");
+	const singletons = models.filter((m) => m.kind === "singleton");
+	const dictionaries = models.filter((m) => m.kind === "dictionary");
+	const documents = models.filter((m) => m.kind === "document");
+	for (const m of collections) lines.push(`export declare function query(model: '${m.id}'): QueryBuilder<${kebabToPascal(m.id)}>`);
+	lines.push("export declare function query(model: string): QueryBuilder<Record<string, unknown>>");
+	lines.push("");
+	for (const m of singletons) lines.push(`export declare function singleton(model: '${m.id}'): SingletonAccessor<${kebabToPascal(m.id)}>`);
+	lines.push("export declare function singleton(model: string): SingletonAccessor<Record<string, unknown>>");
+	lines.push("");
+	for (const m of dictionaries) lines.push(`export declare function dictionary(model: '${m.id}'): DictionaryAccessor`);
+	lines.push("export declare function dictionary(model: string): DictionaryAccessor");
+	lines.push("");
+	for (const m of documents) lines.push(`export declare function document(model: '${m.id}'): DocumentQuery<${kebabToPascal(m.id)}>`);
+	lines.push("export declare function document(model: string): DocumentQuery<Record<string, unknown>>");
+	lines.push("");
+	lines.push("export interface ContentrainClient {");
+	for (const m of collections) lines.push(`  query(model: '${m.id}'): QueryBuilder<${kebabToPascal(m.id)}>`);
+	lines.push("  query(model: string): QueryBuilder<Record<string, unknown>>");
+	for (const m of singletons) lines.push(`  singleton(model: '${m.id}'): SingletonAccessor<${kebabToPascal(m.id)}>`);
+	lines.push("  singleton(model: string): SingletonAccessor<Record<string, unknown>>");
+	for (const m of dictionaries) lines.push(`  dictionary(model: '${m.id}'): DictionaryAccessor`);
+	lines.push("  dictionary(model: string): DictionaryAccessor");
+	for (const m of documents) lines.push(`  document(model: '${m.id}'): DocumentQuery<${kebabToPascal(m.id)}>`);
+	lines.push("  document(model: string): DocumentQuery<Record<string, unknown>>");
+	lines.push("}");
+	lines.push("");
+	lines.push("export declare function createContentrainClient(): ContentrainClient");
+	lines.push("");
+	return lines.join("\n") + "\n";
+}
+function fieldToTS(field) {
+	switch (field.type) {
+		case "string":
+		case "text":
+		case "email":
+		case "url":
+		case "slug":
+		case "color":
+		case "phone":
+		case "code":
+		case "icon":
+		case "markdown":
+		case "richtext":
+		case "date":
+		case "datetime":
+		case "image":
+		case "video":
+		case "file":
+		case "relation":
+			if (Array.isArray(field.model) && field.model.length > 1) return `{ model: ${field.model.map((m) => `'${m}'`).join(" | ")}; ref: string }`;
+			return "string";
+		case "relations":
+			if (Array.isArray(field.model) && field.model.length > 1) return `Array<{ model: ${field.model.map((m) => `'${m}'`).join(" | ")}; ref: string }>`;
+			return "string[]";
+		case "number":
+		case "integer":
+		case "decimal":
+		case "percent":
+		case "rating": return "number";
+		case "boolean": return "boolean";
+		case "select":
+			if (field.options && field.options.length > 0) return field.options.map((o) => `'${o}'`).join(" | ");
+			return "string";
+		case "array":
+			if (field.items) {
+				if (typeof field.items === "string") return `${primitiveToTS(field.items)}[]`;
+				return `${fieldToTS(field.items)}[]`;
+			}
+			return "unknown[]";
+		case "object":
+			if (field.fields) return `{ ${Object.entries(field.fields).map(([k, v]) => `${k}${v.required ? "" : "?"}: ${fieldToTS(v)}`).join("; ")} }`;
+			return "Record<string, unknown>";
+		default: return "unknown";
+	}
+}
+function primitiveToTS(type) {
+	if ([
+		"string",
+		"text",
+		"email",
+		"url",
+		"slug",
+		"color",
+		"phone",
+		"code",
+		"icon",
+		"markdown",
+		"richtext",
+		"date",
+		"datetime",
+		"image",
+		"video",
+		"file",
+		"relation"
+	].includes(type)) return "string";
+	if ([
+		"number",
+		"integer",
+		"decimal",
+		"percent",
+		"rating"
+	].includes(type)) return "number";
+	if (type === "boolean") return "boolean";
+	return "unknown";
+}
+function kebabToPascal(s) {
+	return s.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+//#endregion
+//#region src/generator/data-emitter.ts
+/** Deterministic JSON: sorted keys, 2-space indent, trailing newline */
+function canonicalStringify(data) {
+	return JSON.stringify(data, (_, v) => {
+		if (v && typeof v === "object" && !Array.isArray(v)) return Object.keys(v).toSorted().reduce((acc, k) => {
+			acc[k] = v[k];
+			return acc;
+		}, {});
+		return v;
+	}, 2);
+}
+async function emitDataModules(models, contentFiles) {
+	return (await Promise.all(contentFiles.map((ref) => emitSingleModule(ref, models)))).filter((r) => r !== null);
+}
+async function emitSingleModule(ref, models) {
+	const model = models.find((m) => m.id === ref.modelId);
+	if (!model) return null;
+	const localeSuffix = ref.locale ? `.${ref.locale}` : "";
+	switch (model.kind) {
+		case "collection": {
+			const raw = await readJson(ref.filePath);
+			if (!raw) return null;
+			const entries = Object.entries(raw).toSorted(([a], [b]) => a.localeCompare(b, "en")).map(([id, fields]) => Object.assign({ id }, fields));
+			return {
+				fileName: `${model.id}${localeSuffix}.mjs`,
+				content: `export default ${canonicalStringify(entries)}\n`
+			};
+		}
+		case "singleton": {
+			const raw = await readJson(ref.filePath);
+			if (!raw) return null;
+			return {
+				fileName: `${model.id}${localeSuffix}.mjs`,
+				content: `export default ${canonicalStringify(raw)}\n`
+			};
+		}
+		case "dictionary": {
+			const raw = await readJson(ref.filePath);
+			if (!raw) return null;
+			return {
+				fileName: `${model.id}${localeSuffix}.mjs`,
+				content: `export default ${canonicalStringify(raw)}\n`
+			};
+		}
+		case "document": {
+			const rawText = await readText(ref.filePath);
+			if (!rawText) return null;
+			const { frontmatter, body } = parseFrontmatter(rawText);
+			const slug = ref.slug ?? model.id;
+			const data = {
+				slug,
+				...frontmatter,
+				content: body
+			};
+			return {
+				fileName: `${model.id}--${slug}${localeSuffix}.mjs`,
+				content: `export default ${canonicalStringify(data)}\n`
+			};
+		}
+		default: return null;
+	}
+}
+function parseFrontmatter(text) {
+	const normalized = text.replace(/\r\n/g, "\n");
+	const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+	if (!match) return {
+		frontmatter: {},
+		body: normalized
+	};
+	const fmStr = match[1];
+	const body = match[2].trim();
+	const frontmatter = {};
+	const lines = fmStr.split("\n");
+	const stack = [{
+		obj: frontmatter,
+		indent: -1
+	}];
+	for (const line of lines) {
+		if (line.trim() === "") continue;
+		const arrayMatch = line.match(/^(\s*)-\s+(.*)$/);
+		if (arrayMatch) {
+			const arrIndent = arrayMatch[1].length;
+			const value = arrayMatch[2].trim();
+			while (stack.length > 1 && stack[stack.length - 1].indent >= arrIndent) stack.pop();
+			const parent = stack[stack.length - 1].obj;
+			const lastKey = Object.keys(parent).pop();
+			if (lastKey && Array.isArray(parent[lastKey])) parent[lastKey].push(parseValue(value));
+			continue;
+		}
+		const kvMatch = line.match(/^(\s*)([\w][\w.-]*)\s*:\s*(.*)$/);
+		if (!kvMatch) continue;
+		const kvIndent = kvMatch[1].length;
+		const key = kvMatch[2];
+		const rawValue = kvMatch[3].trim();
+		while (stack.length > 1 && stack[stack.length - 1].indent >= kvIndent) stack.pop();
+		const current = stack[stack.length - 1].obj;
+		if (rawValue === "") {
+			const nextLineIdx = lines.indexOf(line) + 1;
+			if ((nextLineIdx < lines.length ? lines[nextLineIdx] : "").trim().startsWith("-")) current[key] = [];
+			else {
+				const nested = {};
+				current[key] = nested;
+				stack.push({
+					obj: nested,
+					indent: kvIndent
+				});
+			}
+			continue;
+		}
+		if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+			current[key] = rawValue.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+			continue;
+		}
+		current[key] = parseValue(rawValue);
+	}
+	return {
+		frontmatter,
+		body
+	};
+}
+function parseValue(raw) {
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	if (raw === "null") return null;
+	if (/^-?\d+$/.test(raw)) return parseInt(raw, 10);
+	if (/^-?\d+\.\d+$/.test(raw)) return parseFloat(raw);
+	if (raw.startsWith("\"") && raw.endsWith("\"") || raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1);
+	return raw;
+}
+//#endregion
+//#region src/generator/runtime-emitter.ts
+function emitRuntimeModule(models, dataModules, defaultLocale) {
+	const lines = [
+		"/* eslint-disable */",
+		"/* oxlint-disable */",
+		"// Auto-generated by @contentrain/query — do not edit manually",
+		""
+	];
+	if (defaultLocale) {
+		lines.push(`const _defaultLocale = '${defaultLocale}'`);
+		lines.push("");
+	}
+	for (const dm of dataModules) {
+		const varName = fileNameToVar(dm.fileName);
+		lines.push(`import ${varName} from './data/${dm.fileName}'`);
+	}
+	lines.push("");
+	lines.push(RUNTIME_CODE);
+	lines.push("");
+	lines.push("// ─── Data Registry ───");
+	lines.push("");
+	const modelDataMap = /* @__PURE__ */ new Map();
+	for (const dm of dataModules) {
+		const { modelId, locale } = parseDataFileName(dm.fileName);
+		if (!modelDataMap.has(modelId)) modelDataMap.set(modelId, []);
+		modelDataMap.get(modelId).push({
+			varName: fileNameToVar(dm.fileName),
+			locale
+		});
+	}
+	const collections = models.filter((m) => m.kind === "collection");
+	const singletons = models.filter((m) => m.kind === "singleton");
+	const dictionaries = models.filter((m) => m.kind === "dictionary");
+	const documents = models.filter((m) => m.kind === "document");
+	const relationMetaMap = buildRelationMetaMap(models);
+	if (relationMetaMap.size > 0) {
+		lines.push("// ─── Relation Resolver ───");
+		lines.push("");
+		lines.push("function _resolveEntry(model, id, locale) {");
+		lines.push("  const localeKey = locale ?? '_default'");
+		if (collections.length > 0) {
+			lines.push("  const colData = _collectionRegistry[model]?.get(localeKey)");
+			lines.push("  if (colData) { const e = colData.find(x => x.id === id); if (e) return e; }");
+		}
+		if (documents.length > 0) {
+			lines.push("  const docData = _documentRegistry[model]?.get(localeKey)");
+			lines.push("  if (docData) { const e = docData.find(x => x.slug === id); if (e) return e; }");
+		}
+		lines.push("  return undefined");
+		lines.push("}");
+		lines.push("");
+		lines.push("const _relationMeta = {");
+		for (const [modelId, meta] of relationMetaMap) {
+			lines.push(`  '${modelId}': {`);
+			for (const [field, info] of Object.entries(meta)) {
+				const targetStr = Array.isArray(info.target) ? `[${info.target.map((t) => `'${t}'`).join(", ")}]` : `'${info.target}'`;
+				lines.push(`    '${field}': { target: ${targetStr}, multi: ${info.multi} },`);
+			}
+			lines.push("  },");
+		}
+		lines.push("}");
+		lines.push("");
+	}
+	if (collections.length > 0) {
+		lines.push("const _collectionRegistry = {");
+		for (const m of collections) {
+			const entries = modelDataMap.get(m.id) ?? [];
+			lines.push(`  '${m.id}': new Map([`);
+			for (const e of entries) {
+				const localeKey = e.locale ?? "_default";
+				lines.push(`    ['${localeKey}', ${e.varName}],`);
+			}
+			lines.push("  ]),");
+		}
+		lines.push("}");
+		lines.push("");
+		lines.push("export function query(model) {");
+		lines.push("  const data = _collectionRegistry[model]");
+		lines.push("  if (!data) throw new Error(`Unknown collection model: \"${model}\"`)");
+		if (relationMetaMap.size > 0 && defaultLocale) lines.push("  return new QueryBuilder(data, _relationMeta[model], _resolveEntry, _defaultLocale)");
+		else if (relationMetaMap.size > 0) lines.push("  return new QueryBuilder(data, _relationMeta[model], _resolveEntry)");
+		else if (defaultLocale) lines.push("  return new QueryBuilder(data, undefined, undefined, _defaultLocale)");
+		else lines.push("  return new QueryBuilder(data)");
+		lines.push("}");
+		lines.push("");
+	}
+	if (singletons.length > 0) {
+		lines.push("const _singletonRegistry = {");
+		for (const m of singletons) {
+			const entries = modelDataMap.get(m.id) ?? [];
+			lines.push(`  '${m.id}': new Map([`);
+			for (const e of entries) {
+				const localeKey = e.locale ?? "_default";
+				lines.push(`    ['${localeKey}', ${e.varName}],`);
+			}
+			lines.push("  ]),");
+		}
+		lines.push("}");
+		lines.push("");
+		lines.push("export function singleton(model) {");
+		lines.push("  const data = _singletonRegistry[model]");
+		lines.push("  if (!data) throw new Error(`Unknown singleton model: \"${model}\"`)");
+		if (relationMetaMap.size > 0 && defaultLocale) lines.push("  return new SingletonAccessor(data, _defaultLocale, _relationMeta[model], _resolveEntry)");
+		else if (relationMetaMap.size > 0) lines.push("  return new SingletonAccessor(data, undefined, _relationMeta[model], _resolveEntry)");
+		else if (defaultLocale) lines.push("  return new SingletonAccessor(data, _defaultLocale)");
+		else lines.push("  return new SingletonAccessor(data)");
+		lines.push("}");
+		lines.push("");
+	}
+	if (dictionaries.length > 0) {
+		lines.push("const _dictionaryRegistry = {");
+		for (const m of dictionaries) {
+			const entries = modelDataMap.get(m.id) ?? [];
+			lines.push(`  '${m.id}': new Map([`);
+			for (const e of entries) {
+				const localeKey = e.locale ?? "_default";
+				lines.push(`    ['${localeKey}', ${e.varName}],`);
+			}
+			lines.push("  ]),");
+		}
+		lines.push("}");
+		lines.push("");
+		lines.push("export function dictionary(model) {");
+		lines.push("  const data = _dictionaryRegistry[model]");
+		lines.push("  if (!data) throw new Error(`Unknown dictionary model: \"${model}\"`)");
+		lines.push(defaultLocale ? "  return new DictionaryAccessor(data, _defaultLocale)" : "  return new DictionaryAccessor(data)");
+		lines.push("}");
+		lines.push("");
+	}
+	if (documents.length > 0) {
+		for (const m of documents) {
+			const entries = modelDataMap.get(m.id) ?? [];
+			const byLocale = /* @__PURE__ */ new Map();
+			for (const e of entries) {
+				const localeKey = e.locale ?? "_default";
+				if (!byLocale.has(localeKey)) byLocale.set(localeKey, []);
+				byLocale.get(localeKey).push(e.varName);
+			}
+			lines.push(`const _doc_${m.id.replace(/-/g, "_")} = new Map([`);
+			for (const [localeKey, varNames] of byLocale) lines.push(`  ['${localeKey}', [${varNames.join(", ")}]],`);
+			lines.push("])");
+		}
+		lines.push("");
+		lines.push("const _documentRegistry = {");
+		for (const m of documents) lines.push(`  '${m.id}': _doc_${m.id.replace(/-/g, "_")},`);
+		lines.push("}");
+		lines.push("");
+		lines.push("export function document(model) {");
+		lines.push("  const data = _documentRegistry[model]");
+		lines.push("  if (!data) throw new Error(`Unknown document model: \"${model}\"`)");
+		if (relationMetaMap.size > 0 && defaultLocale) lines.push("  return new DocumentQuery(data, _relationMeta[model], _resolveEntry, _defaultLocale)");
+		else if (relationMetaMap.size > 0) lines.push("  return new DocumentQuery(data, _relationMeta[model], _resolveEntry)");
+		else if (defaultLocale) lines.push("  return new DocumentQuery(data, undefined, undefined, _defaultLocale)");
+		else lines.push("  return new DocumentQuery(data)");
+		lines.push("}");
+		lines.push("");
+	}
+	return lines.join("\n") + "\n";
+}
+function emitCjsWrapper(models) {
+	const exports = [];
+	if (models.some((m) => m.kind === "collection")) exports.push("query");
+	if (models.some((m) => m.kind === "singleton")) exports.push("singleton");
+	if (models.some((m) => m.kind === "dictionary")) exports.push("dictionary");
+	if (models.some((m) => m.kind === "document")) exports.push("document");
+	return `/* eslint-disable */
+/* oxlint-disable */
+// Auto-generated CJS proxy — delegates to ESM via dynamic import()
+// Sync usage: const client = require('#contentrain'); client.query('model')
+// Async usage: const client = await require('#contentrain').init()
+'use strict'
+let _mod = null
+let _promise = null
+
+function _ensure() {
+  if (_mod) return _mod
+  throw new Error(
+    'Contentrain client not initialized. Call .init() first, then access exports.\\n'
+    + 'Example: require("#contentrain").init().then(c => c.query("model"))'
+  )
+}
+
+module.exports.init = function() {
+  if (!_promise) _promise = import('./index.mjs').then(function(m) {
+    _mod = m
+${exports.map((e) => `    module.exports.${e} = m.${e}`).join("\n")}
+    return module.exports
+  })
+  return _promise
+}
+
+// Eagerly start loading so subsequent sync calls work after first await
+_promise = import('./index.mjs').then(function(m) {
+  _mod = m
+${exports.map((e) => `  module.exports.${e} = m.${e}`).join("\n")}
+  return module.exports
+}).catch(function() { _promise = null; /* retry on next init() call */ })
+`;
+}
+function buildRelationMetaMap(models) {
+	const result = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		if (!model.fields) continue;
+		const meta = {};
+		let hasRelations = false;
+		for (const [fieldName, field] of Object.entries(model.fields)) if (field.type === "relation" && field.model) {
+			meta[fieldName] = {
+				target: field.model,
+				multi: false
+			};
+			hasRelations = true;
+		} else if (field.type === "relations" && field.model) {
+			meta[fieldName] = {
+				target: field.model,
+				multi: true
+			};
+			hasRelations = true;
+		}
+		if (hasRelations) result.set(model.id, meta);
+	}
+	return result;
+}
+function fileNameToVar(fileName) {
+	return "_" + fileName.replace(".mjs", "").split(/[-.]/).map((p, i) => i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function parseDataFileName(fileName) {
+	const base = fileName.replace(".mjs", "");
+	let nameForLocale = base;
+	if (base.includes("--")) nameForLocale = base;
+	const parts = nameForLocale.split(".");
+	let locale = null;
+	let nameWithoutLocale = nameForLocale;
+	if (parts.length >= 2) {
+		const possibleLocale = parts[parts.length - 1];
+		if (possibleLocale.length === 2 || possibleLocale.includes("-")) {
+			locale = possibleLocale;
+			nameWithoutLocale = parts.slice(0, -1).join(".");
+		}
+	}
+	return {
+		modelId: nameWithoutLocale.includes("--") ? nameWithoutLocale.split("--")[0] : nameWithoutLocale,
+		locale
+	};
+}
+const RUNTIME_CODE = `
+// ─── Runtime Classes ───
+
+class QueryBuilder {
+  constructor(data, relationMeta, resolver, defaultLocale) { this._data = data; this._filters = []; this._sortField = null; this._sortOrder = 'asc'; this._limit = null; this._offset = 0; this._locale = null; this._includes = []; this._relationMeta = relationMeta || {}; this._resolver = resolver || null; this._defaultLocale = defaultLocale || null; }
+  locale(lang) { this._locale = lang; return this; }
+  where(field, value) { this._filters.push(item => { const v = item[field]; return Array.isArray(v) ? v.includes(value) : v === value; }); return this; }
+  sort(field, order = 'asc') { this._sortField = field; this._sortOrder = order; return this; }
+  limit(n) { this._limit = n; return this; }
+  offset(n) { this._offset = n; return this; }
+  include(...fields) { this._includes.push(...fields); return this; }
+  all() {
+    let items; if (this._locale) { items = [...(this._data.get(this._locale) ?? [])]; } else if (this._defaultLocale && this._data.has(this._defaultLocale)) { items = [...this._data.get(this._defaultLocale)]; } else { items = [...(this._data.get(this._data.keys().next().value) ?? [])]; }
+    for (const f of this._filters) items = items.filter(f);
+    if (this._sortField) { const sf = this._sortField; const d = this._sortOrder === 'asc' ? 1 : -1; items.sort((a, b) => { const va = a[sf], vb = b[sf]; if (va == null && vb == null) return 0; if (va == null) return d; if (vb == null) return -d; return va < vb ? -d : va > vb ? d : 0; }); }
+    if (this._offset > 0 || this._limit !== null) { const end = this._limit !== null ? this._offset + this._limit : undefined; items = items.slice(this._offset, end); }
+    if (this._includes.length > 0 && this._resolver) { items = items.map(item => this._resolveIncludes(item)); }
+    return items;
+  }
+  first() { return this.all()[0]; }
+  _resolveIncludes(item) {
+    const resolved = { ...item };
+    for (const field of this._includes) {
+      const meta = this._relationMeta[field]; if (!meta) continue;
+      const targets = Array.isArray(meta.target) ? meta.target : [meta.target];
+      if (meta.multi) { const ids = item[field]; if (Array.isArray(ids)) { resolved[field] = ids.map(id => { if (typeof id === 'string') { for (const t of targets) { const r = this._resolver(t, id, this._locale); if (r) return r; } return id; } if (typeof id === 'object' && id !== null && 'model' in id && 'ref' in id) { const r = this._resolver(id.model, id.ref, this._locale); if (r) return r; } return id; }); } }
+      else { const id = item[field]; if (typeof id === 'string') { for (const t of targets) { const r = this._resolver(t, id, this._locale); if (r) { resolved[field] = r; break; } } } else if (typeof id === 'object' && id !== null && 'model' in id && 'ref' in id) { const r = this._resolver(id.model, id.ref, this._locale); if (r) resolved[field] = r; } }
+    }
+    return resolved;
+  }
+}
+
+class SingletonAccessor {
+  constructor(data, defaultLocale, relationMeta, resolveEntry) { this._data = data; this._locale = null; this._defaultLocale = defaultLocale || null; this._includes = []; this._relationMeta = relationMeta || {}; this._resolver = resolveEntry; }
+  locale(lang) { this._locale = lang; return this; }
+  include(...fields) { this._includes.push(...fields); return this; }
+  get() {
+    const locale = this._locale || this._defaultLocale;
+    let d = locale ? this._data.get(locale) : undefined;
+    if (!d) { const key = this._data.keys().next().value; d = key !== undefined ? this._data.get(key) : undefined; }
+    if (!d) throw new Error('No data available');
+    if (this._includes.length > 0 && this._resolver) return this._resolveIncludes(d, locale || 'en');
+    return d;
+  }
+  _resolveIncludes(item, locale) {
+    const resolved = { ...item };
+    for (const field of this._includes) {
+      const meta = this._relationMeta[field]; if (!meta) continue;
+      const targets = Array.isArray(meta.target) ? meta.target : [meta.target];
+      if (meta.multi) { const ids = item[field]; if (Array.isArray(ids)) { resolved[field] = ids.map(id => { if (typeof id === 'string') { for (const t of targets) { const r = this._resolver(t, id, locale); if (r) return r; } return id; } if (typeof id === 'object' && id !== null && 'model' in id && 'ref' in id) { const r = this._resolver(id.model, id.ref, locale); if (r) return r; } return id; }); } }
+      else { const id = item[field]; if (typeof id === 'string') { for (const t of targets) { const r = this._resolver(t, id, locale); if (r) { resolved[field] = r; break; } } } else if (typeof id === 'object' && id !== null && 'model' in id && 'ref' in id) { const r = this._resolver(id.model, id.ref, locale); if (r) resolved[field] = r; } }
+    }
+    return resolved;
+  }
+}
+
+class DictionaryAccessor {
+  constructor(data, defaultLocale) { this._data = data; this._locale = null; this._defaultLocale = defaultLocale || null; }
+  locale(lang) { this._locale = lang; return this; }
+  get(key, params) {
+    let dict; if (this._locale) { dict = this._data.get(this._locale) ?? {}; } else if (this._defaultLocale && this._data.has(this._defaultLocale)) { dict = this._data.get(this._defaultLocale); } else { const loc = this._data.keys().next().value; dict = this._data.get(loc) ?? {}; }
+    if (key === undefined) return dict;
+    const val = dict[key];
+    if (val === undefined) return undefined;
+    if (params) return val.replace(/{(w+)}/g, (m, k) => { const v = params[k]; return v !== undefined ? String(v) : m; });
+    return val;
+  }
+}
+
+class DocumentQuery {
+  constructor(data, relationMeta, resolver, defaultLocale) { this._data = data; this._filters = []; this._locale = null; this._includes = []; this._relationMeta = relationMeta || {}; this._resolver = resolver || null; this._defaultLocale = defaultLocale || null; }
+  locale(lang) { this._locale = lang; return this; }
+  where(field, value) { this._filters.push(item => item[field] === value); return this; }
+  include(...fields) { this._includes.push(...fields); return this; }
+  bySlug(slug) {
+    const items = this._resolveData(); const item = items.find(x => x.slug === slug);
+    if (item && this._includes.length > 0 && this._resolver) return this._resolveIncludes(item);
+    return item;
+  }
+  first() { return this.all()[0]; }
+  all() { let items = this._resolveData(); for (const f of this._filters) items = items.filter(f); if (this._includes.length > 0 && this._resolver) { items = items.map(item => this._resolveIncludes(item)); } return items; }
+  _resolveData() { let key; if (this._locale) { key = this._locale; } else if (this._defaultLocale && this._data.has(this._defaultLocale)) { key = this._defaultLocale; } else { key = this._data.keys().next().value; } return [...(this._data.get(key) ?? [])]; }
+  _resolveIncludes(item) {
+    const resolved = { ...item };
+    for (const field of this._includes) {
+      const meta = this._relationMeta[field]; if (!meta) continue;
+      const targets = Array.isArray(meta.target) ? meta.target : [meta.target];
+      if (meta.multi) { const ids = item[field]; if (Array.isArray(ids)) { resolved[field] = ids.map(id => { if (typeof id === 'string') { for (const t of targets) { const r = this._resolver(t, id, this._locale); if (r) return r; } return id; } if (typeof id === 'object' && id !== null && 'model' in id && 'ref' in id) { const r = this._resolver(id.model, id.ref, this._locale); if (r) return r; } return id; }); } }
+      else { const id = item[field]; if (typeof id === 'string') { for (const t of targets) { const r = this._resolver(t, id, this._locale); if (r) { resolved[field] = r; break; } } } else if (typeof id === 'object' && id !== null && 'model' in id && 'ref' in id) { const r = this._resolver(id.model, id.ref, this._locale); if (r) resolved[field] = r; } }
+    }
+    return resolved;
+  }
+}
+`.trim();
+//#endregion
+//#region src/generator/package-json.ts
+const IMPORTS_CONFIG = {
+	"#contentrain": {
+		types: "./.contentrain/client/index.d.ts",
+		import: "./.contentrain/client/index.mjs",
+		require: "./.contentrain/client/index.cjs",
+		default: "./.contentrain/client/index.mjs"
+	},
+	"#contentrain/*": {
+		types: "./.contentrain/client/*.d.ts",
+		import: "./.contentrain/client/*.mjs",
+		require: "./.contentrain/client/*.cjs",
+		default: "./.contentrain/client/*.mjs"
+	}
+};
+async function injectImports(projectRoot) {
+	const pkgPath = (0, node_path.join)(projectRoot, "package.json");
+	const pkg = await readJson(pkgPath);
+	if (!pkg) return false;
+	const existing = pkg["imports"] ?? {};
+	const updated = {
+		...existing,
+		...IMPORTS_CONFIG
+	};
+	if (JSON.stringify(existing["#contentrain"]) === JSON.stringify(IMPORTS_CONFIG["#contentrain"]) && JSON.stringify(existing["#contentrain/*"]) === JSON.stringify(IMPORTS_CONFIG["#contentrain/*"])) return false;
+	pkg["imports"] = updated;
+	await writeText(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+	return true;
+}
+//#endregion
+//#region src/generator/generate.ts
+async function generate(options) {
+	const { projectRoot } = options;
+	const clientDir = (0, node_path.join)(projectRoot, ".contentrain", "client");
+	const dataDir = (0, node_path.join)(clientDir, "data");
+	const manifest = await readProjectManifest(projectRoot);
+	const dataModules = await emitDataModules(manifest.models, manifest.contentFiles);
+	const typesContent = emitTypes(manifest.models);
+	const runtimeContent = emitRuntimeModule(manifest.models, dataModules, manifest.config.locales.default);
+	const cjsContent = emitCjsWrapper(manifest.models);
+	const newFileNames = new Set(dataModules.map((dm) => dm.fileName));
+	try {
+		const existing = await readDir(dataDir);
+		await Promise.all(existing.filter((f) => !newFileNames.has(f)).map((f) => (0, node_fs_promises.rm)((0, node_path.join)(dataDir, f), { force: true })));
+	} catch {}
+	const dataFileNames = dataModules.map((dm) => `data/${dm.fileName}`);
+	await Promise.all([
+		writeText((0, node_path.join)(clientDir, "index.d.ts"), typesContent),
+		writeText((0, node_path.join)(clientDir, "index.mjs"), runtimeContent),
+		writeText((0, node_path.join)(clientDir, "index.cjs"), cjsContent),
+		...dataModules.map((dm) => writeText((0, node_path.join)(dataDir, dm.fileName), dm.content))
+	]);
+	const packageJsonUpdated = await injectImports(projectRoot);
+	return {
+		generatedFiles: [
+			"index.d.ts",
+			...dataFileNames,
+			"index.mjs",
+			"index.cjs"
+		],
+		typesCount: manifest.models.length,
+		dataModulesCount: dataModules.length,
+		packageJsonUpdated
+	};
+}
+//#endregion
+Object.defineProperty(exports, "generate", {
+	enumerable: true,
+	get: function() {
+		return generate;
+	}
+});