@likec4/config 1.48.0 → 1.49.0

package/dist/node/index.mjs

@@ -1,40 +1,27 @@
-import { t } from "../_chunks/libs/remeda.mjs";
+import { t as defu } from "../_chunks/libs/defu.mjs";
+import { i as t, n as t$1, r as e, t as n } from "../_chunks/libs/remeda.mjs";
 import JSON5 from "json5";
 import z from "zod/v4";
 import { BorderStyles, ElementShapes, IconPositions, RelationshipArrowTypes, Sizes, ThemeColors, computeColorValues } from "@likec4/core/styles";
 import { exact } from "@likec4/core/types";
+import { basename } from "pathe";
 import { invariant } from "@likec4/core";
-import { rootLogger } from "@likec4/log";
+import { logger, wrapError } from "@likec4/log";
 import { bundleRequire } from "bundle-require";
+import { formatMessagesSync } from "esbuild";
 import * as fs from "node:fs/promises";
-import { dirname } from "node:path";
-
-//#region src/schema.image-alias.ts
+import { basename as basename$1, dirname, resolve } from "node:path";
 const IMAGE_ALIAS_KEY_REGEX = /^@[A-Za-z0-9_-]*$/;
 const IMAGE_ALIAS_VALUE_REGEX = /^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/;
+const ImageAliasKey = z.string().min(1, "Image alias key cannot be empty").regex(IMAGE_ALIAS_KEY_REGEX, "Image alias key must match /^@\\w+$/");
 const ImageAliasValue = z.string().min(1, "Image alias value cannot be empty").regex(IMAGE_ALIAS_VALUE_REGEX, "Image alias value must be a relative path (no leading slash or protocol)");
-const ImageAliasesSchema = z.record(z.string(), ImageAliasValue).meta({ description: "Map of image alias prefixes to relative paths (keys must match /^@\\w+$/; values must be relative paths without protocol or leading slash)." });
-function validateImageAliases(imageAliases) {
-	const invalidKeys = [];
-	const invalidValues = [];
-	if (imageAliases) for (const [key, value] of Object.entries(imageAliases)) {
-		if (!IMAGE_ALIAS_KEY_REGEX.test(key)) invalidKeys.push(key);
-		if (!IMAGE_ALIAS_VALUE_REGEX.test(value)) invalidValues.push(`${key} -> ${value}`);
-	}
-	if (invalidKeys.length || invalidValues.length) {
-		const parts = [];
-		if (invalidKeys.length) parts.push(`Invalid image alias key(s): ${invalidKeys.map((k) => JSON.stringify(k)).join(", ")} (must match ${IMAGE_ALIAS_KEY_REGEX})`);
-		if (invalidValues.length) parts.push(`Invalid image alias value(s): ${invalidValues.map((kv) => JSON.stringify(kv)).join(", ")} (must match ${IMAGE_ALIAS_VALUE_REGEX})`);
-		throw new Error(parts.join(" | "));
-	}
-}
-
-//#endregion
-//#region src/schema.include.ts
-const RELATIVE_PATH_REGEX = /^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/;
-const IncludePathValue = z.string().min(1, "Include path cannot be empty").regex(RELATIVE_PATH_REGEX, "Include path must be a relative path (no leading slash, drive letter, or protocol)");
-const IncludeConfigSchema = z.strictObject({
-	paths: z.array(IncludePathValue).min(1, "Include paths cannot be empty").meta({ description: [
+const ImageAliasesSchema = z.record(ImageAliasKey, ImageAliasValue).meta({
+	id: "ImageAliases",
+	description: "Map of image alias prefixes to relative paths (keys must match /^@\\w+$/; values must be relative paths without protocol or leading slash)."
+});
+const IncludePathValue = z.string().min(1, "Include path cannot be empty").regex(/^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/, "Include path must be a relative path (no leading slash, drive letter, or protocol)");
+const IncludeSchema = z.strictObject({
+	paths: z.array(IncludePathValue).meta({ description: [
 		"Additional relative directory paths to include LikeC4 source files from, searched recursively.",
 		"Paths are relative to the project folder (the folder containing this config file).",
 		"Example: [\"../shared\", \"../common/specs\"]"
@@ -44,54 +31,33 @@ const IncludeConfigSchema = z.strictObject({
 		"Prevents excessive scanning of deeply nested directories.",
 		"Default: 3"
 	].join("\n") }),
-	fileThreshold: z.number().int().min(1).default(30).meta({ description: [
+	fileThreshold: z.number().int().min(1).max(1e4).default(30).meta({ description: [
 		"Maximum number of files to load from include paths before warning.",
 		"Helps identify performance issues from accidentally including large directories.",
 		"Default: 30"
 	].join("\n") })
 }).meta({
 	id: "include-config",
-	description: "Configuration for including additional LikeC4 source files"
+	description: ["Configuration for including additional LikeC4 source files from other directories.", "Example: { \"paths\": [\"../shared\", \"../common/specs\"], \"maxDepth\": 5, \"fileThreshold\": 50 }"].join("\n")
 });
-const IncludeSchema = IncludeConfigSchema.optional().meta({ description: ["Configuration for including additional LikeC4 source files from other directories.", "Example: { \"paths\": [\"../shared\", \"../common/specs\"], \"maxDepth\": 5, \"fileThreshold\": 50 }"].join("\n") });
-function normalizeIncludeConfig(include) {
-	if (!include) return {
-		paths: [],
-		maxDepth: 3,
-		fileThreshold: 30
-	};
-	return include;
-}
-function validateIncludePaths(include) {
-	if (!include?.paths) return;
-	const invalidPaths = [];
-	for (const path of include.paths) if (!RELATIVE_PATH_REGEX.test(path)) invalidPaths.push(path);
-	if (invalidPaths.length > 0) throw new Error(`Invalid include path(s): ${invalidPaths.map((p) => JSON.stringify(p)).join(", ")} (must be relative paths without leading slash, drive letter, or protocol)`);
-}
-
-//#endregion
-//#region src/schema.theme.ts
 const opacity = z.int().min(0, "Opacity must be between 0 and 100").max(100, "Opacity must be between 0 and 100").meta({
 	id: "Opacity",
 	description: "Opacity 0-100%"
 });
-const shape = z.literal(ElementShapes).meta({ id: "ElementShape" });
-const border = z.literal(BorderStyles).meta({ id: "BorderStyle" });
-const size = z.literal(Sizes).meta({ id: "ElementSize" });
-const iconPosition = z.literal(IconPositions).meta({ id: "IconPosition" });
-const arrow = z.literal(RelationshipArrowTypes).meta({ id: "ArrowType" });
-const line = z.literal([
+const shape = z.enum(ElementShapes).meta({ id: "ElementShape" });
+const border = z.enum(BorderStyles).meta({ id: "BorderStyle" });
+const size = z.enum(Sizes).meta({ id: "ElementSize" });
+const iconPosition = z.enum(IconPositions).meta({ id: "IconPosition" });
+const arrow = z.enum(RelationshipArrowTypes).meta({ id: "ArrowType" });
+const line = z.enum([
 	"dashed",
 	"solid",
 	"dotted"
 ]).meta({ id: "LineType" });
-const themeColor = z.literal(ThemeColors).meta({ id: "ThemeColor" });
-const customColor = z.string().min(1, "Custom color name cannot be empty").transform((value) => value).meta({ id: "CustomColorName" });
-const color = z.union([themeColor, customColor]).transform((value) => value).meta({ id: "ColorName" });
-const colorSchema = z.string().min(1, "Color value cannot be empty").transform((value) => value).meta({
-	id: "ColorLiteral",
-	description: "Color value in any valid CSS format: hex, rgb, rgba, hsl, hsla ..."
-});
+const themeColor = z.enum(ThemeColors).meta({ id: "ThemeColorName" });
+const customColor = z.custom().refine((v) => typeof v === "string", "Custom color name must be a string").transform((value) => value).meta({ id: "CustomColorName" });
+const color = themeColor.or(customColor).transform((value) => value).meta({ id: "ColorName" });
+const colorSchema = z.string().min(1, "Color value cannot be empty").meta({ id: "ColorLiteral" });
 const ElementColorValuesSchema = z.strictObject({
 	fill: colorSchema.meta({ description: "Background color" }),
 	stroke: colorSchema.meta({ description: "Stroke color (border, paths above background)" }),
@@ -103,44 +69,31 @@ const RelationshipColorValuesSchema = z.strictObject({
 	label: colorSchema.meta({ description: "Label text color" }),
 	labelBg: colorSchema.optional().default("rgba(0, 0, 0, 0.5)").meta({ description: "Label background color" })
 }).meta({ id: "RelationshipColorValues" }).transform((value) => value);
-const StrictThemeColorValuesSchema = z.strictObject({
-	elements: z.union([colorSchema, ElementColorValuesSchema]).meta({ description: "Element color value (or a breakdown of specific color values)" }).transform((value) => {
-		if (typeof value === "string") return computeColorValues(value).elements;
-		return value;
-	}),
-	relationships: z.union([colorSchema, RelationshipColorValuesSchema]).meta({ description: "Relationship color value (or a breakdown of specific color values)" }).transform((value) => {
-		if (typeof value === "string") return computeColorValues(value).relationships;
-		return value;
-	})
-}).meta({ id: "StrictThemeColorValues" });
-const ThemeColorValuesSchema = z.union([colorSchema, StrictThemeColorValuesSchema]).meta({
+const ThemeColorValuesSchema = z.strictObject({
+	elements: ElementColorValuesSchema.or(colorSchema.transform((v) => computeColorValues(v).elements)).meta({ description: "Exact color value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color values" }),
+	relationships: RelationshipColorValuesSchema.or(colorSchema.transform((v) => computeColorValues(v).relationships)).meta({ description: "Exact color value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color values" })
+}).transform((value) => value).meta({
+	id: "StrictThemeColorValues",
+	description: "Exact color value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color value"
+}).or(colorSchema.transform((v) => computeColorValues(v))).transform((value) => value).meta({
 	id: "ThemeColorValues",
 	description: "Exact value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color values"
-}).transform((value) => {
-	if (typeof value === "string") return computeColorValues(value);
-	return value;
 });
-const ThemeColorsSchema = z.record(color, ThemeColorValuesSchema).meta({
-	id: "ThemeColors",
-	description: "Override theme colors"
-}).transform((value) => value);
+const ThemeColorsSchema = z.partialRecord(color, ThemeColorValuesSchema).transform((value) => value);
 const DimensionsSchema = z.strictObject({
 	width: z.number().min(50),
 	height: z.number().min(50)
 }).meta({
 	id: "Dimensions",
-	description: "Dimensions"
-});
-const LikeC4Config_Styles_Theme_Sizes = z.strictObject(t(Sizes, () => DimensionsSchema.optional())).meta({
-	id: "ThemeSizes",
-	description: "Override theme sizes"
+	description: "Defines dimensions for theme size"
 });
+const LikeC4Config_Styles_Theme_Sizes = z.partialRecord(size, DimensionsSchema);
 const LikeC4Config_Styles_Theme = z.strictObject({
-	colors: ThemeColorsSchema.optional(),
-	sizes: LikeC4Config_Styles_Theme_Sizes.optional()
+	colors: ThemeColorsSchema.optional().meta({ description: "Override theme colors" }),
+	sizes: LikeC4Config_Styles_Theme_Sizes.optional().meta({ description: "Override theme sizes" })
 }).meta({
 	id: "ThemeCustomization",
-	description: "Theme customization"
+	description: "Customize theme colors and sizes"
 }).transform(({ colors, sizes }) => {
 	return exact({
 		colors: colors ? exact(colors) : void 0,
@@ -151,10 +104,7 @@ const LikeC4Config_Styles_Defaults_Group = z.strictObject({
 	color: color.optional().meta({ description: "Default color for groups\n(must be a valid color name from the theme)" }),
 	opacity: opacity.optional().meta({ description: "Default opacity for groups" }),
 	border: border.optional().meta({ description: "Default border for groups" })
-}).meta({
-	id: "GroupDefaultStyleValues",
-	description: "Override default values for group style properties\nThese values will be used if such property is not defined"
-});
+}).meta({ id: "GroupDefaultStyleValues" });
 const LikeC4Config_Styles_Defaults_Relationship = z.strictObject({
 	color: color.optional().meta({ description: "Default color for relationships\n(must be a valid color name from the theme)" }),
 	line: line.optional().meta({ description: "Default line style for relationships" }),
@@ -170,23 +120,14 @@ const LikeC4Config_Styles_Defaults = z.strictObject({
 	size: size.optional().meta({ description: "Default size for elements" }),
 	shape: shape.optional().meta({ description: "Default shape for elements" }),
 	iconPosition: iconPosition.optional().meta({ description: "Default icon position for elements" }),
-	group: LikeC4Config_Styles_Defaults_Group.optional().meta({ description: "Default style values for groups" }),
-	relationship: LikeC4Config_Styles_Defaults_Relationship.optional().meta({ description: "Default style values for relationships" })
-}).meta({
-	id: "DefaultStyleValues",
-	description: "Override default values for style properties\nThese values will be used if such property is not defined"
-});
-const LikeC4Config_Styles_CustomStylesheets = z.union([z.string().min(1, "Custom CSS file path cannot be empty"), z.array(z.string().min(1, "Custom CSS file path cannot be empty"))]).meta({
-	id: "CustomStylesheets",
-	description: "Custom CSS (or list of CSS files) to be included in the generated diagrams"
-});
+	group: LikeC4Config_Styles_Defaults_Group.optional().meta({ description: "Override default values for group style properties\nThese values will be used if such property is not defined" }),
+	relationship: LikeC4Config_Styles_Defaults_Relationship.optional().meta({ description: "Override default values for relationship style properties\nThese values will be used if such property is not defined" })
+}).meta({ id: "DefaultStyleValues" });
+const LikeC4Config_Styles_CustomStylesheets = z.union([z.string().min(1, "Custom CSS file path cannot be empty"), z.array(z.string().min(1, "Custom CSS file path cannot be empty"))]).meta({ id: "CustomStylesheets" });
 const LikeC4StylesConfigSchema = z.strictObject({
-	theme: LikeC4Config_Styles_Theme.optional(),
-	defaults: LikeC4Config_Styles_Defaults.optional(),
-	customCss: LikeC4Config_Styles_CustomStylesheets.optional()
-}).meta({
-	id: "StylesConfiguration",
-	description: "Project styles customization"
+	theme: LikeC4Config_Styles_Theme.optional().meta({ description: "Project theme customization" }),
+	defaults: LikeC4Config_Styles_Defaults.optional().meta({ description: "Override default values for style properties\nThese values will be used if such property is not defined" }),
+	customCss: LikeC4Config_Styles_CustomStylesheets.optional().meta({ description: "Custom CSS (or list of CSS files) to be included in the generated diagrams" })
 }).transform(({ theme, defaults, customCss }) => exact({
 	defaults: normalizeDefaults(defaults),
 	customCss: normalizeStylesheets(customCss),
@@ -210,16 +151,13 @@ function normalizeStylesheets(stylesheets) {
 		content: ""
 	};
 }
-
-//#endregion
-//#region src/schema.ts
 const ManualLayoutsConfigSchema = z.strictObject({ outDir: z.string().default(".likec4").meta({ description: [
 	"Path to the directory where manual layouts will be stored,",
 	"relative to the folder containing the project config. ",
 	"",
 	"Defaults to '.likec4'."
 ].join("\n") }) }).meta({
-	id: "manual-layouts-config",
+	id: "ManualLayoutsConfig",
 	description: "Configuration for manual layouts"
 });
 const LikeC4ProjectJsonConfigSchema = z.object({
@@ -230,30 +168,42 @@ const LikeC4ProjectJsonConfigSchema = z.object({
 		abort: true,
 		error: "Project name cannot contain \".\", \"@\" or \"#\", try to use A-z, 0-9, _ and -"
 	}).meta({ description: "Project name, must be unique in the workspace" }),
+	extends: z.union([z.string().min(1, "Extend path cannot be empty"), z.array(z.string().min(1, "Extend path cannot be empty")).min(1, "Extend list cannot be empty")]).optional().meta({ description: "Extend styles from other config files" }),
 	title: z.string().nonempty("Project title cannot be empty if specified").optional().meta({ description: "A human readable title for the project" }),
 	contactPerson: z.string().nonempty("Contact person cannot be empty if specified").optional().meta({ description: "A person who has been involved in creating or maintaining this project" }),
+	styles: LikeC4StylesConfigSchema.optional().meta({ description: "Project styles customization" }),
 	imageAliases: ImageAliasesSchema.optional(),
-	include: IncludeSchema,
-	styles: LikeC4StylesConfigSchema.optional(),
+	include: IncludeSchema.optional(),
 	exclude: z.array(z.string()).optional().meta({ description: "List of file patterns to exclude from the project, default is [\"**/node_modules/**\"]" }),
 	manualLayouts: ManualLayoutsConfigSchema.optional()
-}).meta({ description: "LikeC4 project configuration" });
+}).meta({
+	id: "LikeC4ProjectConfig",
+	description: "LikeC4 Project Configuration"
+});
 const FunctionType = z.instanceof(Function);
 const GeneratorsSchema = z.record(z.string(), FunctionType);
 const LikeC4ProjectConfigSchema = LikeC4ProjectJsonConfigSchema.extend({ generators: GeneratorsSchema.optional() });
-/**
-* Validates JSON string or JSON object into a LikeC4ProjectConfig object.
-*/
 function validateProjectConfig(config) {
-	const parsed = LikeC4ProjectConfigSchema.safeParse(typeof config === "string" ? JSON5.parse(config) : config);
-	if (!parsed.success) throw new Error("Config validation failed:\n" + z.prettifyError(parsed.error));
-	if (parsed.data.imageAliases) validateImageAliases(parsed.data.imageAliases);
-	if (parsed.data.include) validateIncludePaths(parsed.data.include);
-	return parsed.data;
+	const parsed = LikeC4ProjectConfigSchema.safeParse(config);
+	if (parsed.success) return parsed.data;
+	throw new Error("Config validation failed:\n" + z.prettifyError(parsed.error));
+}
+function parseProjectConfigJSON(config) {
+	return validateProjectConfig(JSON5.parse(config.trim() || "{}"));
 }
-
-//#endregion
-//#region src/filenames.ts
+const LikeC4ProjectConfigOps = {
+	parse: parseProjectConfigJSON,
+	validate: validateProjectConfig,
+	normalizeInclude: (include) => {
+		const parsed = IncludeSchema.safeParse(include);
+		if (parsed.success) return parsed.data;
+		return {
+			paths: [],
+			maxDepth: 3,
+			fileThreshold: 30
+		};
+	}
+};
 const configJsonFilenames = [
 	".likec4rc",
 	".likec4.config.json",
@@ -268,195 +218,115 @@ const configNonJsonFilenames = [
 	"likec4.config.mts"
 ];
 const ConfigFilenames = [...configJsonFilenames, ...configNonJsonFilenames];
-/**
-* Checks if the given filename is a LikeC4 JSON config file (JSON, RC).
-*/
 function isLikeC4JsonConfig(filename) {
-	for (const ext of configJsonFilenames) if (filename.endsWith(ext)) return true;
-	return false;
+	return configJsonFilenames.includes(basename(filename));
 }
-/**
-* Checks if the given filename is a LikeC4 non-JSON config file (JS, MJS, TS, MTS)
-*/
 function isLikeC4NonJsonConfig(filename) {
-	for (const ext of configNonJsonFilenames) if (filename.endsWith(ext)) return true;
-	return false;
+	return configNonJsonFilenames.includes(basename(filename));
 }
-/**
-* Checks if the given filename is a LikeC4 config file (JSON or non-JSON)
-*/
 function isLikeC4Config(filename) {
 	return isLikeC4JsonConfig(filename) || isLikeC4NonJsonConfig(filename);
 }
-
-//#endregion
-//#region src/define-config.ts
-/**
-* Defines LikeC4 Project, allows custom generators that can be executed using CLI:
-*
-* `$ likec4 gen <generator-name>`
-*
-* or VSCode command `LikeC4: Run code generator`
-*
-* @example
-* ```ts
-* export default defineConfig({
-*   name: 'my-project',
-*   title: 'My Project',
-*
-*   exclude: ['picomatch pattern'],
-*   generators: {
-*     '<generator-name>': async ({ likec4model, ctx }) => {
-*       await ctx.write('my-generator.txt', likec4model.project.id)
-*     }
-*   }
-* })
-* ```
-*/
 function defineConfig(config) {
 	return LikeC4ProjectConfigSchema.parse(config);
 }
-/**
-* Define reusable custom generators
-*
-* @example
-* ```ts
-* // generators.ts
-* export default defineGenerators({
-*   'my-generator': async ({ likec4model, ctx }) => {
-*     await ctx.write('my-generator.txt', likec4model.project.id)
-*   }
-* })
-*
-* // likec4.config.ts
-* import generators from './generators'
-*
-* export default defineConfig({
-*   name: 'my-project',
-*   generators,
-* })
-* ```
-*/
 function defineGenerators(generators) {
 	return GeneratorsSchema.parse(generators);
 }
-/**
-* Define reusable custom theme color
-* @example
-* ```ts
-* export default defineThemeColor({
-*   element: {
-*     fill: 'red'
-*   }
-* })
-* ```
-*/
 function defineThemeColor(colors) {
 	return ThemeColorValuesSchema.parse(colors);
 }
-/**
-* Define reusable custom theme
-* @example
-* ```ts
-* import { defineThemeColor, defineTheme } from 'likec4/config'
-*
-* export default defineTheme({
-*   colors: {
-*     primary: '#FF0000',
-*     // Or use defineThemeColor
-*     red: defineThemeColor({
-*       elements: {
-*         fill: 'red'
-*       }
-*     })
-*   }
-* })
-* ```
-*/
 function defineTheme(theme) {
 	return LikeC4Config_Styles_Theme.parse(theme);
 }
-/**
-* Define reusable custom style
-* @example
-* ```ts
-* import { defineStyle, defineThemeColor } from 'likec4/config'
-*
-* export default defineStyle({
-*   theme: {
-*     colors: {
-*       red: defineThemeColor({
-*         elements: {
-*           fill: 'red'
-*         }
-*       })
-*     }
-*   },
-*   defaults: {
-*     color: 'red',
-*     opacity: 50,
-*     border: 'solid',
-*     size: 'sm',
-*     relationship: {
-*       color: 'grey',
-*       line: 'solid',
-*     }
-*   }
-* })
-*/
 function defineStyle(styles) {
 	return LikeC4StylesConfigSchema.parse(styles);
 }
-
-//#endregion
-//#region src/node/load-config.ts
-/**
-* Load LikeC4 Project config file.
-* If filepath is a non-JSON file, it will be bundled and required
-*/
+const JsonConfigInputSchema = LikeC4ProjectJsonConfigSchema.pick({
+	extends: true,
+	styles: true
+}).loose();
+const normalizeExtends = (value) => {
+	if (!value) return [];
+	return Array.isArray(value) ? value : [value];
+};
+const parseJsonConfig = async (filepath) => {
+	const content = await fs.readFile(filepath, "utf-8");
+	let parsed;
+	try {
+		parsed = JSON5.parse(content.trim() || "{}");
+	} catch (e) {
+		throw wrapError(e, `${filepath}:`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`${filepath}: Config must be a JSON object`);
+	const result = JsonConfigInputSchema.safeParse(parsed);
+	if (!result.success) throw new Error(`${filepath}: Invalid config\n` + z.prettifyError(result.error));
+	return result.data;
+};
+const loadJsonConfigs = async (filepath, stack) => {
+	if (stack.includes(filepath)) {
+		const cycleStart = stack.indexOf(filepath);
+		const cycle = [...stack.slice(cycleStart), filepath].join(" -> ");
+		throw new Error(`Config extends cycle detected: ${cycle}`);
+	}
+	const parsed = await parseJsonConfig(filepath);
+	const extendsPaths = normalizeExtends(parsed.extends);
+	const nextStack = [...stack, filepath];
+	const configs = [];
+	for (const extendPath of extendsPaths) {
+		const resolvedPath = resolve(dirname(filepath), extendPath);
+		configs.push(...await loadJsonConfigs(resolvedPath, nextStack));
+	}
+	return [...configs, parsed];
+};
 async function loadConfig(filepath) {
-	const logger = rootLogger.getChild("config");
-	logger.debug`Loading config file: ${filepath.fsPath}`;
-	if (isLikeC4JsonConfig(filepath.fsPath)) try {
-		return validateProjectConfig(await fs.readFile(filepath.fsPath, "utf-8"));
-	} catch (err) {
-		logger.error(`Failed to load json config file: ${filepath.fsPath}`, { err });
-		throw err;
+	filepath = typeof filepath === "string" ? filepath : filepath.fsPath;
+	logger.getChild("config").debug`Loading config: ${filepath}`;
+	const folder = dirname(filepath);
+	const filename = basename$1(filepath);
+	const implicitcfg = { name: basename$1(folder) };
+	if (isLikeC4JsonConfig(filename)) {
+		const configs = await loadJsonConfigs(resolve(filepath), []);
+		invariant(t(configs, 1), "Expect at least one config");
+		const rootConfig = n(t$1(configs), ["extends", "styles"]);
+		const stylesChain = configs.map((config) => config.styles).filter(e);
+		const mergedStyles = stylesChain.length > 0 ? defu({}, ...stylesChain.reverse()) : void 0;
+		return validateProjectConfig({
+			...implicitcfg,
+			...rootConfig,
+			...mergedStyles ? { styles: mergedStyles } : {}
+		});
 	}
-	invariant(isLikeC4NonJsonConfig(filepath.fsPath), `Invalid config file: ${filepath.fsPath}`);
-	try {
-		const cwd = dirname(filepath.fsPath);
-		const { mod } = await bundleRequire({
-			filepath: filepath.fsPath,
-			cwd,
-			esbuildOptions: {
-				resolveExtensions: [
-					".ts",
-					".mts",
-					".cts",
-					".mjs",
-					".js",
-					".cjs"
-				],
-				plugins: [{
-					name: "likec4-config",
-					setup(build) {
-						/**
-						* Intercept @likec4/config and likec4/config imports
-						*/
-						build.onResolve({ filter: /^@?likec4\/config$/ }, (args) => ({
-							path: args.path,
-							namespace: "likec4-config"
-						}));
-						/**
-						* Mock implementation, this allows to skip redundant bundling @likec4/config
-						*/
-						build.onLoad({
-							filter: /.*/,
-							namespace: "likec4-config"
-						}, (_args) => {
-							return {
-								contents: `
+	invariant(isLikeC4NonJsonConfig(filename), `Invalid name for config file: ${filepath}`);
+	const { mod } = await bundleRequire({
+		filepath,
+		cwd: folder,
+		esbuildOptions: {
+			resolveExtensions: [
+				".ts",
+				".mts",
+				".cts",
+				".mjs",
+				".js",
+				".cjs"
+			],
+			plugins: [{
+				name: "likec4-config",
+				setup(build) {
+					build.onResolve({ filter: /^@?likec4\/config$/ }, (args) => ({
+						path: args.path,
+						namespace: "likec4-config"
+					}));
+					build.onEnd((result) => {
+						const messages = formatMessagesSync(result.errors, { kind: "error" });
+						for (const message of messages) logger.error(message);
+					});
+					build.onLoad({
+						filter: /.*/,
+						namespace: "likec4-config"
+					}, (_args) => {
+						return {
+							contents: `
 // Mock implementation to allow loading config files without bundling @likec4/config
 function mock(x) { return x }
 export {
@@ -466,19 +336,13 @@ export {
   mock as defineTheme,
   mock as defineThemeColor,
 }`,
-								loader: "js"
-							};
-						});
-					}
-				}]
-			}
-		});
-		return defineConfig(mod?.default ?? mod);
-	} catch (err) {
-		logger.error(`Failed to load config file: ${filepath.fsPath}`, { err });
-		throw err;
-	}
+							loader: "js"
+						};
+					});
+				}
+			}]
+		}
+	});
+	return validateProjectConfig(Object.assign(implicitcfg, mod?.default ?? mod));
 }
-
-//#endregion
-export { ConfigFilenames, defineConfig, defineGenerators, defineStyle, defineTheme, defineThemeColor, isLikeC4Config, isLikeC4JsonConfig, isLikeC4NonJsonConfig, loadConfig, normalizeIncludeConfig, validateIncludePaths, validateProjectConfig };
+export { ConfigFilenames, LikeC4ProjectConfigOps, defineConfig, defineGenerators, defineStyle, defineTheme, defineThemeColor, isLikeC4Config, isLikeC4JsonConfig, isLikeC4NonJsonConfig, loadConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/config",
-  "version": "1.48.0",
+  "version": "1.49.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -54,14 +54,15 @@
   },
   "dependencies": {
     "json5": "^2.2.3",
+    "pathe": "^2.0.3",
     "zod": "^3.25.76",
     "type-fest": "^4.41.0",
-    "@likec4/core": "1.48.0",
-    "@likec4/log": "1.48.0"
+    "@likec4/log": "1.49.0",
+    "@likec4/core": "1.49.0"
   },
   "peerDependencies": {
     "bundle-require": "^5.1.0",
-    "esbuild": "0.27.2"
+    "esbuild": "0.27.3"
   },
   "peerDependenciesMeta": {
     "esbuild": {
@@ -72,19 +73,21 @@
     }
   },
   "devDependencies": {
-    "@types/node": "~22.19.7",
-    "remeda": "^2.32.0",
+    "@types/node": "~22.19.10",
+    "remeda": "^2.33.5",
     "defu": "^6.1.4",
+    "ufo": "1.6.3",
     "tsx": "4.21.0",
-    "turbo": "2.7.6",
+    "turbo": "2.8.3",
     "typescript": "5.9.3",
-    "obuild": "^0.4.20",
+    "obuild": "^0.4.27",
     "nano-spawn": "^2.0.0",
     "vitest": "4.0.18",
-    "@likec4/tsconfig": "1.48.0",
-    "@likec4/devops": "1.42.0"
+    "@likec4/devops": "1.42.0",
+    "@likec4/tsconfig": "1.49.0"
   },
   "scripts": {
+    "generate": "tsx --conditions=sources scripts/generate.mts",
     "typecheck": "tsc -b --verbose",
     "build": "obuild",
     "lint:package": "pnpx publint ./package.tgz",