@likec4/config 1.48.0 → 1.50.0

package/dist/node/index.mjs

@@ -1,40 +1,26 @@
-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 { 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, 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 +30,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 +68,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 +103,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 +119,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 +150,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,35 +167,79 @@ 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" }),
+	metadata: z.record(z.string(), z.any()).optional().meta({ description: "Arbitrary metadata as key-value pairs for custom project information" }),
+	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" });
+	manualLayouts: ManualLayoutsConfigSchema.optional(),
+	inferTechnologyFromIcon: z.boolean().optional().meta({ description: [
+		"Automatically derive element technology from icon name when technology is not set explicitly.",
+		"Applies to aws:, azure:, gcp:, and tech: icons. Bootstrap icons are excluded.",
+		"Defaults to true."
+	].join("\n") }),
+	implicitViews: z.boolean().optional().meta({ description: "Auto-generate scoped views for elements without explicit views. Defaults to true." })
+}).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.
+* Validates 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));
 }
-
-//#endregion
-//#region src/filenames.ts
+/**
+* Parses JSON string into a LikeC4ProjectConfig object.
+* Does not process "extends" - use `loadConfig` function instead
+*/
+function parseProjectConfigJSON(config) {
+	return validateProjectConfig(JSON5.parse(config.trim() || "{}"));
+}
+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
+		};
+	}
+};
+/** Trim trailing slashes and backslashes (no regex, avoids S5852 ReDoS). */
+function trimTrailingSlashes(s) {
+	let end = s.length;
+	while (end > 0 && (s[end - 1] === "/" || s[end - 1] === "\\")) end--;
+	return s.slice(0, end);
+}
+/** Split by / or \ without regex (avoids S5852 ReDoS). */
+function splitPath(s) {
+	return s.split("/").flatMap((part) => part.split("\\"));
+}
+/** basename compatible with Node and browser (no node:path for Vite/playground bundle). */
+function basename$1(path) {
+	const trimmed = trimTrailingSlashes(path);
+	const segments = splitPath(trimmed);
+	return segments[segments.length - 1] || trimmed;
+}
+/** Known LikeC4 JSON config filenames (RC and .json). */
 const configJsonFilenames = [
 	".likec4rc",
 	".likec4.config.json",
 	"likec4.config.json"
 ];
+/** Known LikeC4 non-JSON config filenames (JS, MJS, TS, MTS). */
 const configNonJsonFilenames = [
 	"likec4.config.js",
 	"likec4.config.cjs",
@@ -267,30 +248,24 @@ const configNonJsonFilenames = [
 	"likec4.config.cts",
 	"likec4.config.mts"
 ];
+/** All known LikeC4 config filenames (JSON and non-JSON). */
 const ConfigFilenames = [...configJsonFilenames, ...configNonJsonFilenames];
-/**
-* Checks if the given filename is a LikeC4 JSON config file (JSON, RC).
-*/
+/** Returns true if the **basename** of the given path matches a known config filename. */
 function isLikeC4JsonConfig(filename) {
-	for (const ext of configJsonFilenames) if (filename.endsWith(ext)) return true;
-	return false;
+	return configJsonFilenames.includes(basename$1(filename));
 }
 /**
-* Checks if the given filename is a LikeC4 non-JSON config file (JS, MJS, TS, MTS)
+* Returns true if the **basename** of the given path matches a known non-JSON config filename (JS, MJS, TS, MTS).
 */
 function isLikeC4NonJsonConfig(filename) {
-	for (const ext of configNonJsonFilenames) if (filename.endsWith(ext)) return true;
-	return false;
+	return configNonJsonFilenames.includes(basename$1(filename));
 }
 /**
-* Checks if the given filename is a LikeC4 config file (JSON or non-JSON)
+* Returns true if the **basename** of the given path matches a known 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:
 *
@@ -407,56 +382,101 @@ function defineTheme(theme) {
 function defineStyle(styles) {
 	return LikeC4StylesConfigSchema.parse(styles);
 }
-
-//#endregion
-//#region src/node/load-config.ts
+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];
+};
 /**
 * Load LikeC4 Project config file.
 * If filepath is a non-JSON file, it will be bundled and required
 */
 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(filepath);
+	const implicitcfg = { name: basename(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) {
+					/**
+					* Intercept @likec4/config and likec4/config imports
+					*/
+					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);
+					});
+					/**
+					* Mock implementation, this allows to skip redundant bundling @likec4/config
+					*/
+					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 +486,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.50.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -56,12 +56,12 @@
     "json5": "^2.2.3",
     "zod": "^3.25.76",
     "type-fest": "^4.41.0",
-    "@likec4/core": "1.48.0",
-    "@likec4/log": "1.48.0"
+    "@likec4/core": "1.50.0",
+    "@likec4/log": "1.50.0"
   },
   "peerDependencies": {
     "bundle-require": "^5.1.0",
-    "esbuild": "0.27.2"
+    "esbuild": "0.27.3"
   },
   "peerDependenciesMeta": {
     "esbuild": {
@@ -72,19 +72,21 @@
     }
   },
   "devDependencies": {
-    "@types/node": "~22.19.7",
-    "remeda": "^2.32.0",
+    "@types/node": "~22.19.11",
+    "remeda": "^2.33.5",
     "defu": "^6.1.4",
+    "ufo": "1.6.3",
     "tsx": "4.21.0",
-    "turbo": "2.7.6",
+    "turbo": "2.8.10",
     "typescript": "5.9.3",
-    "obuild": "^0.4.20",
+    "obuild": "^0.4.31",
     "nano-spawn": "^2.0.0",
     "vitest": "4.0.18",
-    "@likec4/tsconfig": "1.48.0",
+    "@likec4/tsconfig": "1.50.0",
     "@likec4/devops": "1.42.0"
   },
   "scripts": {
+    "generate": "tsx --conditions=sources scripts/generate.mts",
     "typecheck": "tsc -b --verbose",
     "build": "obuild",
     "lint:package": "pnpx publint ./package.tgz",