@bamboocss/config 1.30.1 → 1.32.0

package/dist/diff-config.cjs

@@ -51,14 +51,12 @@ function createMatcher(id, patterns) {
 const all = [
 	"clean",
 	"cwd",
-	"eject",
 	"outdir",
 	"forceConsistentTypeExtension",
 	"outExtension",
 	"emitTokensOnly",
 	"presets",
-	"plugins",
-	"hooks"
+	"plugins"
 ];
 const format = [
 	"hash",
@@ -103,7 +101,7 @@ const artifactConfigDeps = {
 	"types-entry": [],
 	"types-gen": [],
 	"types-gen-system": [],
-	themes: ["themes"].concat(tokens),
+	themes: ["theme.variants"].concat(tokens),
 	"static-css": [
 		"staticCss",
 		"patterns",
@@ -117,6 +115,7 @@ const artifactMatchers = Object.entries(artifactConfigDeps).map(([key, paths]) =
 	if (!paths.length) return () => void 0;
 	return createMatcher(key, paths.concat(all));
 });
+Array.from(new Set([...all, ...Object.values(artifactConfigDeps).flat()]));
 //#endregion
 //#region src/diff-config.ts
 const runIfFn = (fn) => typeof fn === "function" ? fn() : fn;

package/dist/diff-config.mjs

@@ -27,14 +27,12 @@ function createMatcher(id, patterns) {
 const all = [
 	"clean",
 	"cwd",
-	"eject",
 	"outdir",
 	"forceConsistentTypeExtension",
 	"outExtension",
 	"emitTokensOnly",
 	"presets",
-	"plugins",
-	"hooks"
+	"plugins"
 ];
 const format = [
 	"hash",
@@ -79,7 +77,7 @@ const artifactConfigDeps = {
 	"types-entry": [],
 	"types-gen": [],
 	"types-gen-system": [],
-	themes: ["themes"].concat(tokens),
+	themes: ["theme.variants"].concat(tokens),
 	"static-css": [
 		"staticCss",
 		"patterns",
@@ -93,6 +91,7 @@ const artifactMatchers = Object.entries(artifactConfigDeps).map(([key, paths]) =
 	if (!paths.length) return () => void 0;
 	return createMatcher(key, paths.concat(all));
 });
+Array.from(new Set([...all, ...Object.values(artifactConfigDeps).flat()]));
 //#endregion
 //#region src/diff-config.ts
 const runIfFn = (fn) => typeof fn === "function" ? fn() : fn;

package/dist/index.cjs

@@ -28,14 +28,14 @@ let escalade_sync = require("escalade/sync");
 escalade_sync = __toESM(escalade_sync);
 let path = require("path");
 path = __toESM(path);
+let _bamboocss_preset_base = require("@bamboocss/preset-base");
+let _bamboocss_preset_bamboo = require("@bamboocss/preset-bamboo");
 let microdiff = require("microdiff");
 microdiff = __toESM(microdiff);
 let fs = require("fs");
 fs = __toESM(fs);
 let typescript = require("typescript");
 typescript = __toESM(typescript);
-let _bamboocss_preset_base = require("@bamboocss/preset-base");
-let _bamboocss_preset_bamboo = require("@bamboocss/preset-bamboo");
 //#region src/is-bamboo-config.ts
 const configName = "bamboo";
 const bambooConfigFiles = new Set([
@@ -86,6 +86,25 @@ async function bundleConfig(options) {
 	};
 }
 //#endregion
+//#region src/bundled-preset.ts
+const bundledPresets = {
+	"@bamboocss/preset-base": _bamboocss_preset_base.preset,
+	"@bamboocss/preset-bamboo": _bamboocss_preset_bamboo.preset,
+	"@bamboocss/dev/presets": _bamboocss_preset_bamboo.preset
+};
+const bundledPresetsNames = Object.keys(bundledPresets);
+const isBundledPreset = (preset) => bundledPresetsNames.includes(preset);
+const getBundledPreset = (preset) => {
+	return typeof preset === "string" && isBundledPreset(preset) ? bundledPresets[preset] : void 0;
+};
+/**
+* What `presets` loads when a config does not list any.
+*
+* Exported so a config that adds a preset can keep them without restating them:
+* `presets: [...defaultPresets, myPreset]`. Spread it — the array is shared.
+*/
+const defaultPresets = [_bamboocss_preset_base.preset, _bamboocss_preset_bamboo.preset];
+//#endregion
 //#region src/create-matcher.ts
 /**
 * Acts like a .gitignore matcher
@@ -113,14 +132,12 @@ function createMatcher(id, patterns) {
 const all = [
 	"clean",
 	"cwd",
-	"eject",
 	"outdir",
 	"forceConsistentTypeExtension",
 	"outExtension",
 	"emitTokensOnly",
 	"presets",
-	"plugins",
-	"hooks"
+	"plugins"
 ];
 const format = [
 	"hash",
@@ -165,7 +182,7 @@ const artifactConfigDeps = {
 	"types-entry": [],
 	"types-gen": [],
 	"types-gen-system": [],
-	themes: ["themes"].concat(tokens),
+	themes: ["theme.variants"].concat(tokens),
 	"static-css": [
 		"staticCss",
 		"patterns",
@@ -179,6 +196,7 @@ const artifactMatchers = Object.entries(artifactConfigDeps).map(([key, paths]) =
 	if (!paths.length) return () => void 0;
 	return createMatcher(key, paths.concat(all));
 });
+Array.from(new Set([...all, ...Object.values(artifactConfigDeps).flat()]));
 //#endregion
 //#region src/diff-config.ts
 const runIfFn = (fn) => typeof fn === "function" ? fn() : fn;
@@ -505,18 +523,35 @@ const tryCatch = (name, fn) => {
 };
 //#endregion
 //#region src/validation/utils.ts
-const REFERENCE_REGEX = /({([^}]*)})/g;
-const curlyBracketRegex = /[{}]/g;
+/**
+* A reference to another token: `token(colors.red.300)`.
+*
+* Deliberately a copy of the regex in `@bamboocss/token-dictionary`, which this package does not
+* depend on. The two must agree: validation is what reports a missing or circular reference, so a
+* spelling only the dictionary understands is one this never checks — which is silence, not an
+* error, and exactly what a spelling change here is most likely to cause.
+*/
+const REFERENCE_REGEX = /token\(([^(),]+)\)/g;
 const isValidToken = (token) => (0, _bamboocss_shared.isObject)(token) && Object.hasOwnProperty.call(token, "value");
-const isTokenReference = (value) => typeof value === "string" && REFERENCE_REGEX.test(value);
+const isTokenReference = (value) => typeof value === "string" && getReferences(value).length > 0;
+/**
+* The retired curly reference — `{colors.red.300}`, or `{$spacing-2}` under a custom
+* `formatTokenName`. A copy of the regex in `@bamboocss/token-dictionary`, which this package
+* does not depend on.
+*
+* Reported here as well as there because a *token* value carrying one is the worse case: the
+* text is emitted into the stylesheet rather than dropped, and validation is the only thing that
+* can name which token it came from.
+*/
+const CURLY_REFERENCE = /\{[^{}\s:;"']+\}/;
+const findCurlyReference = (value) => value.includes("{") ? CURLY_REFERENCE.exec(value)?.[0] ?? void 0 : void 0;
+/** The retired `token(path, fallback)` form. See `findCurlyReference` for why these fail. */
+const FALLBACK_REFERENCE = /token\([^(),]+,[^()]*\)/;
+const findFallbackReference = (value) => value.includes("token(") ? FALLBACK_REFERENCE.exec(value)?.[0] ?? void 0 : void 0;
 const formatPath = (path) => path;
 function getReferences(value) {
 	if (typeof value !== "string") return [];
-	const matches = value.match(REFERENCE_REGEX);
-	if (!matches) return [];
-	return matches.map((match) => match.replace(curlyBracketRegex, "")).map((value) => {
-		return value.trim().split("/")[0];
-	});
+	return [...value.matchAll(REFERENCE_REGEX)].map((match) => match[1].trim().split("/")[0]).filter(Boolean);
 }
 const serializeTokenValue = (value) => {
 	if ((0, _bamboocss_shared.isString)(value)) return value;
@@ -573,28 +608,71 @@ const tokenKeys = [
 	"deprecated"
 ];
 /**
+* Options whose scalar form is shorthand for setting every member of their object form.
+*
+* `hash: true` says both `cssVar` and `className`; `prefix: 'bb'` says both; `preflight: true`
+* says "on, with the defaults". Expanding them is what lets the object forms compose: a preset
+* that sets `prefix.className` and an app that sets `prefix.cssVar` should end up with both,
+* and before this the app's object replaced the preset's wholesale — silently, since the two
+* name different members. `hash`'s members are optional, so writing the partial form that
+* triggered it is the natural thing to do.
+*
+* `preflight: false` has no object form — there is no member meaning "off" — so it stays a
+* scalar and wins outright when it is the value the winning config states.
+*/
+const SCALAR_SHORTHANDS = {
+	hash: (value) => typeof value === "boolean" ? {
+		cssVar: value,
+		className: value
+	} : value,
+	prefix: (value) => typeof value === "string" ? {
+		cssVar: value,
+		className: value
+	} : value,
+	preflight: (value) => value === true ? {} : value
+};
+/**
+* Merge one of those, winner-first per member.
+*
+* `records` arrives in precedence order — the user's config, then each preset — which is the
+* order `assign` wants, since it only fills keys the target does not already have.
+*/
+function mergeScalarShorthand(key, records) {
+	const normalize = SCALAR_SHORTHANDS[key];
+	const values = records.map((record) => record[key]).filter((value) => value !== void 0);
+	if (!values.length) return void 0;
+	if (values[0] === false) return false;
+	const objects = values.map(normalize).filter((value) => value !== null && typeof value === "object");
+	if (!objects.length) return values[0];
+	const merged = objects.reduce((acc, object) => (0, _bamboocss_shared.assign)(acc, object), {});
+	return isEmptyObject(merged) ? values[0] : merged;
+}
+/**
 * Merge all configs into a single config
 */
 function mergeConfigs(configs) {
-	const userConfig = configs.at(-1);
-	const pluginHooks = userConfig.plugins ?? [];
-	if (userConfig.hooks) pluginHooks.push({
-		name: _bamboocss_shared.BAMBOO_CONFIG_NAME,
-		hooks: userConfig.hooks
-	});
 	const reversed = Array.from(configs).reverse();
+	const theme = mergeExtensions(reversed.map((config) => config.theme ?? {}));
+	const themeVariants = mergeExtensions(reversed.map((config) => config.theme?.variants ?? {}));
+	if (isEmptyObject(themeVariants)) delete theme.variants;
+	else theme.variants = themeVariants;
+	const global = compact({
+		css: mergeExtensions(reversed.map((config) => config.global?.css ?? {})),
+		vars: mergeExtensions(reversed.map((config) => config.global?.vars ?? {})),
+		fontface: mergeExtensions(reversed.map((config) => config.global?.fontface ?? {})),
+		positionTry: mergeExtensions(reversed.map((config) => config.global?.positionTry ?? {}))
+	});
 	const withoutEmpty = compact((0, _bamboocss_shared.assign)({
 		conditions: mergeExtensions(reversed.map((config) => config.conditions ?? {})),
-		theme: mergeExtensions(reversed.map((config) => config.theme ?? {})),
+		theme,
 		patterns: mergeExtensions(reversed.map((config) => config.patterns ?? {})),
 		utilities: mergeExtensions(reversed.map((config) => config.utilities ?? {})),
-		globalCss: mergeExtensions(reversed.map((config) => config.globalCss ?? {})),
-		globalVars: mergeExtensions(reversed.map((config) => config.globalVars ?? {})),
-		globalFontface: mergeExtensions(reversed.map((config) => config.globalFontface ?? {})),
-		globalPositionTry: mergeExtensions(reversed.map((config) => config.globalPositionTry ?? {})),
+		global,
 		staticCss: mergeExtensions(reversed.map((config) => config.staticCss ?? {})),
-		themes: mergeExtensions(reversed.map((config) => config.themes ?? {})),
-		hooks: mergeHooks(pluginHooks)
+		prune: mergeExtensions(reversed.map((config) => config.prune ?? {})),
+		hash: mergeScalarShorthand("hash", reversed),
+		prefix: mergeScalarShorthand("prefix", reversed),
+		preflight: mergeScalarShorthand("preflight", reversed)
 	}, ...reversed));
 	/**
 	* Properly merge tokens between flat/nested forms by setting the flat form as the default
@@ -679,18 +757,6 @@ async function getResolvedConfig(config, cwd, hooks) {
 	return merged;
 }
 //#endregion
-//#region src/bundled-preset.ts
-const bundledPresets = {
-	"@bamboocss/preset-base": _bamboocss_preset_base.preset,
-	"@bamboocss/preset-bamboo": _bamboocss_preset_bamboo.preset,
-	"@bamboocss/dev/presets": _bamboocss_preset_bamboo.preset
-};
-const bundledPresetsNames = Object.keys(bundledPresets);
-const isBundledPreset = (preset) => bundledPresetsNames.includes(preset);
-const getBundledPreset = (preset) => {
-	return typeof preset === "string" && isBundledPreset(preset) ? bundledPresets[preset] : void 0;
-};
-//#endregion
 //#region src/validation/validate-artifact.ts
 const validateArtifactNames = (names, addError) => {
 	names.recipes.forEach((recipeName) => {
@@ -785,6 +851,145 @@ const validateRecipes = (options) => {
 	return artifacts;
 };
 //#endregion
+//#region src/validation/validate-removed.ts
+/**
+* Config options that no longer exist, and what replaced them.
+*
+* An unknown key is otherwise *silently ignored* — nothing walks the config for keys it does not
+* recognise. So removing an option without this leaves the worst possible upgrade: the build
+* reverts to the default and says nothing, and an assertion the user asked for simply stops being
+* enforced. That is exactly the shape a renamed prune flag would have taken.
+*
+* Keyed by the removed name so the message can say what to write instead, rather than reporting a
+* bare "unknown option". Entries can be dropped a release or two after removal, once nobody is
+* upgrading across them.
+*/
+const REMOVED = {
+	pruneUnusedTokens: (value) => value === "strict" ? `\`pruneUnusedTokens: 'strict'\` is now \`prune: { tokens: 'accounted', unresolvedPath: 'error' }\`.` : `\`pruneUnusedTokens\` is now \`prune: { tokens: '${value === false ? "off" : "reachable"}' }\`.`,
+	pruneUnusedKeyframes: (value) => `\`pruneUnusedKeyframes\` is now \`prune: { keyframes: ${value === false ? "false" : "true"} }\`.`,
+	prunePreflight: (value) => `\`prunePreflight\` is now \`prune: { preflight: ${value === false ? "false" : "true"} }\`.`,
+	globalCss: () => `\`globalCss\` is now \`global: { css }\`.`,
+	globalFontface: () => `\`globalFontface\` is now \`global: { fontface }\`.`,
+	globalPositionTry: () => `\`globalPositionTry\` is now \`global: { positionTry }\`.`,
+	globalVars: () => `\`globalVars\` is now \`global: { vars }\`.`,
+	themes: () => `\`themes\` is now \`theme.variants\`. One character from \`theme\`, both spellings valid, so the typo resolved to a different feature instead of an error.`,
+	eject: (value) => value ? `\`eject: true\` is now \`presets: []\`. \`presets\` is the complete list — an unset \`presets\` loads \`defaultPresets\`, and listing your own no longer keeps a default underneath it.` : `\`eject: false\` was the default and no longer exists — delete it. \`presets\` is now the complete list.`,
+	hooks: () => `\`hooks\` is now a plugin: \`plugins: [{ name: 'my-app', hooks: { ... } }]\`. One mechanism had two spellings, and the nameless one left every diagnostic about a hook with nothing to print. Ordering is now just the order of the array, rather than "plugins in sequence, then the config's own last".`,
+	lightningcss: (value) => value ? `\`lightningcss: true\` is now \`plugins: [pluginLightningcss()]\` from \`@bamboocss/plugin-lightningcss\`, which you install yourself. The flag forced a static import, so every project carried the native binary whether or not it was on.` : `\`lightningcss: false\` was the default and no longer exists — delete it.`
+};
+/** Values that no longer exist for an option that does. Keyed by option, then by old value. */
+const RETIRED_VALUES = { validation: { none: `\`validation: 'none'\` is now \`validation: 'off'\`, matching \`prune.unresolvedPath\`.` } };
+/** Removed keys nested one level down, keyed by their parent. */
+const COMPOSITION_MOVED = (old, prop) => () => `\`theme.${old}\` is now \`theme.mixins\`, applied through \`css({ mixin: '…' })\` rather than \`css({ ${prop}: '…' })\`. The three keys ran through one registration and differed only in which properties the value could set — an arbitrary partition that cost a bundle spanning two of them a second key and a second application.`;
+const REMOVED_NESTED = {
+	prune: { unresolved: (value) => `\`prune.unresolved\` is now \`prune.unresolvedPath\`, and the accounting pass it used to switch on is now \`prune.tokens: 'accounted'\` — write \`prune: { tokens: 'accounted', unresolvedPath: '${value === "error" ? "error" : "warn"}' }\`. They are separate because \`'off'\` used to mean two things at once: no accounting, and no report.` },
+	theme: {
+		textStyles: COMPOSITION_MOVED("textStyles", "textStyle"),
+		layerStyles: COMPOSITION_MOVED("layerStyles", "layerStyle"),
+		animationStyles: COMPOSITION_MOVED("animationStyles", "animationStyle")
+	}
+};
+/**
+* Options a config still sets that no longer exist — a hard error, and not silenceable.
+*
+* Runs ahead of `validation` and ignores it, for the reason `assertNoRetiredSyntax` does. The
+* rest of `validateConfig` reports opinions about a config that will still build; this reports a
+* config that is *provably* not the one being read. An unknown key might be forward-compatible —
+* a setting for a version you have not installed yet — but a key on this list is only reachable
+* by a config written against a version that is behind the one running it.
+*
+* It used to warn, which is the wrong severity for exactly the upgrade this exists to catch. A
+* warning scrolls past in CI, and a removed option is silent in every other way: the build
+* reverts to the default and the assertion the user asked for stops being enforced. These
+* removals ship in minor versions, so a Renovate auto-merge sails through a warning without a
+* person ever reading it — the one case where nothing else can catch it.
+*
+* Every occurrence is collected before throwing, because the point is to fix a config once
+* rather than to be told about it one key at a time. Delete this a release or two after removal,
+* along with `validate-retired-syntax.ts`.
+*/
+function assertNoRemovedOptions(config) {
+	const found = [];
+	validateRemovedOptions(config, (scope, message) => {
+		found.push(`- [${scope}] ${message}`);
+	});
+	if (!found.length) return;
+	throw new _bamboocss_shared.BambooError("CONFIG_ERROR", `${found.length} config option(s) no longer exist:\n\n${found.join("\n")}\n\nNothing walks a config for keys it does not recognise, so an option left in place here is reported nowhere else — the build reverts to the default in silence, and any assertion the option asked for stops being enforced. Make the edits above and the build proceeds. This is not governed by \`validation\`, which grades a config that still builds.\n\nThis reads the config after presets are merged, so a key you cannot find in your own file came from one of them — upgrade that preset, or drop the key with a \`config:resolved\` hook.`);
+}
+function validateRemovedOptions(config, addError) {
+	const dict = config;
+	for (const [name, describe] of Object.entries(REMOVED)) {
+		if (!Object.hasOwn(config, name)) continue;
+		addError("config", describe(dict[name]));
+	}
+	for (const [parent, removed] of Object.entries(REMOVED_NESTED)) {
+		const value = dict[parent];
+		if (value == null || typeof value !== "object") continue;
+		for (const [name, describe] of Object.entries(removed)) {
+			if (!Object.hasOwn(value, name)) continue;
+			addError("config", describe(value[name]));
+		}
+	}
+	for (const [name, retired] of Object.entries(RETIRED_VALUES)) {
+		const value = dict[name];
+		if (typeof value !== "string") continue;
+		const message = retired[value];
+		if (message) addError("config", message);
+	}
+	if (typeof dict.prune?.tokens === "boolean") addError("config", `\`prune.tokens\` takes a strategy now, not a boolean — write \`'${dict.prune.tokens ? "reachable" : "off"}'\`. \`'accounted'\` is the new one: keeps computed from the token paths in your source rather than from what the css reaches.`);
+	for (const [name, pattern] of Object.entries(config.patterns ?? {})) {
+		const dictPattern = pattern;
+		if (!dictPattern) continue;
+		if (Object.hasOwn(dictPattern, "strict")) addError("patterns", `\`${name}.strict\` is now \`${name}.cssProps: '${dictPattern.strict ? "none" : "all"}'\`.`);
+		if (Object.hasOwn(dictPattern, "blocklist")) addError("patterns", `\`${name}.blocklist\` is now \`${name}.cssProps: { except: [...] }\`, which is no longer experimental and no longer silently dropped when the pattern also set \`strict\`.`);
+	}
+}
+//#endregion
+//#region src/validation/validate-retired-syntax.ts
+/**
+* Token values still written in a retired reference syntax.
+*
+* A hard error, and one that runs ahead of `validation` rather than under it. The rest of
+* `validateConfig` reports opinions about a config that will still build; this reports a spelling
+* that no longer means anything, whose output is broken either way — in a token value the text is
+* emitted into the stylesheet as-is, and nothing downstream reports it. `validation: 'off'` is an
+* opt-out of opinions, not of that.
+*
+* Safe to throw on because the spelling was never available for anything else: until it was
+* removed, `{…}` in a value was consumed unconditionally — braces stripped, unresolved paths
+* emitted bare — so no literal `{a.b}` could have survived to mean itself.
+*
+* Every occurrence is collected before throwing, because the point is to fix a config once rather
+* than to be told about it one token at a time. Delete this a release or two after removal, along
+* with `validate-removed.ts`.
+*/
+function assertNoRetiredSyntax(config) {
+	const found = [];
+	const collect = (source, label) => {
+		if (!source) return;
+		(0, _bamboocss_shared.walkObject)(source, (token, path) => {
+			if (!isValidToken(token)) return;
+			const value = serializeTokenValue(token.value ?? token);
+			const at = `${label}.${formatPath(path.join("."))}`;
+			const curly = findCurlyReference(value);
+			if (curly) found.push(`- \`${at}\`: \`${curly}\` → \`token(${curly.slice(1, -1)})\``);
+			const fallback = findFallbackReference(value);
+			if (fallback) {
+				const path = fallback.slice(6, fallback.lastIndexOf(",")).trim();
+				found.push(`- \`${at}\`: \`${fallback}\` → \`token(${path})\``);
+			}
+		}, { stop: isValidToken });
+	};
+	collect(config.theme?.tokens, "theme.tokens");
+	collect(config.theme?.semanticTokens, "theme.semanticTokens");
+	for (const [name, variant] of Object.entries(config.theme?.variants ?? {})) {
+		collect(variant?.tokens, `theme.variants.${name}.tokens`);
+		collect(variant?.semanticTokens, `theme.variants.${name}.semanticTokens`);
+	}
+	if (!found.length) return;
+	throw new _bamboocss_shared.BambooError("CONFIG_ERROR", `${found.length} token value(s) use a retired reference syntax:\n\n${found.join("\n")}\n\n\`{colors.red.300}\` and \`token(colors.red.300, fallback)\` were both removed so a token is referenced one way. Neither is ignored quietly — the text is emitted into the stylesheet as-is.`);
+}
+//#endregion
 //#region src/validation/validate-token-references.ts
 const validateTokenReferences = (props) => {
 	const { valueAtPath, refsByPath, addError, typeByPath } = props;
@@ -905,13 +1110,29 @@ const validateTokens = (options) => {
 * - Check for missing tokens references
 * - Check for conditions selectors (must contain '&')
 * - Check for breakpoints units (must be the same)
+* - Throw on options that have been removed, which are otherwise ignored in silence
+* - Throw on token values still written in the retired curly reference syntax
+*
+* The two throwing checks run first and answer to nothing below them. `validation` grades
+* *opinions about a config that still builds*; those two are evidence that the config is not
+* the one being read, which is a different question and not one a severity setting should
+* decide.
 */
 const validateConfig = (config) => {
-	if (config.validation === "none") return;
+	assertNoRetiredSyntax(config);
+	assertNoRemovedOptions(config);
 	const warnings = /* @__PURE__ */ new Set();
 	const addError = (scope, message) => {
 		warnings.add(`[${scope}] ` + message);
 	};
+	const report = () => {
+		if (!warnings.size) return;
+		const errors = `⚠️ Invalid config:\n${Array.from(warnings).map((err) => "- " + err).join("\n")}\n`;
+		if (config.validation === "error") throw new _bamboocss_shared.BambooError("CONFIG_ERROR", errors);
+		_bamboocss_logger.logger.warn("config", errors);
+		return warnings;
+	};
+	if (config.validation === "off") return report();
 	validateBreakpoints(config.theme?.breakpoints, addError);
 	validateConditions(config.conditions, addError);
 	const artifacts = {
@@ -941,12 +1162,7 @@ const validateConfig = (config) => {
 	}
 	validatePatterns(config.patterns, artifacts);
 	validateArtifactNames(artifacts, addError);
-	if (warnings.size) {
-		const errors = `⚠️ Invalid config:\n${Array.from(warnings).map((err) => "- " + err).join("\n")}\n`;
-		if (config.validation === "error") throw new _bamboocss_shared.BambooError("CONFIG_ERROR", errors);
-		_bamboocss_logger.logger.warn("config", errors);
-		return warnings;
-	}
+	return report();
 };
 //#endregion
 //#region src/resolve-config.ts
@@ -956,28 +1172,41 @@ const hookUtils = {
 	traverse: _bamboocss_shared.traverse
 };
 /**
-* Resolve the final config (including presets)
-* @bamboocss/preset-base: ALWAYS included if NOT using eject: true
-* @bamboocss/preset-bamboo: only included by default if no presets
+* The one way this rename can break a config without saying so.
+*
+* `presets` still exists and still takes a list, so nothing in `validate-removed` notices
+* that its meaning changed. A config that listed `[myPreset]` used to get `preset-base`
+* underneath it and now does not — and what `preset-base` carries is the utility table, so
+* the failure is every class name silently changing (`c_red_300` becomes `color_red_300`)
+* rather than an error. That is the shape this codebase treats as the worst upgrade there
+* is, so it gets a message.
+*
+* Skipped for an empty list, which is a deliberate eject and the replacement for
+* `eject: true`. Drop this a release or two after the rename.
+*/
+function warnIfBaseDropped(listed, resolved) {
+	if (!listed?.length) return;
+	if (resolved.some((preset) => preset?.name === "@bamboocss/preset-base")) return;
+	_bamboocss_logger.logger.warn("config", "`presets` is now the complete list, and this one does not include `@bamboocss/preset-base` — so its utilities, conditions and patterns are not loaded, and generated class names change. Listing a preset used to keep `preset-base` underneath it.\n\n  import { defaultPresets } from '@bamboocss/dev/presets'\n  presets: [...defaultPresets, yourPreset]\n\nIf dropping it is deliberate, this is the intended behaviour and the warning goes away once `preset-base` is listed explicitly.");
+}
+/**
+* Resolve the final config (including presets).
+*
+* `presets` is authoritative: what the config lists is what is loaded, and an unset
+* `presets` loads `defaultPresets`. There is no implicit preset a listed one sits on top
+* of — `eject` used to control that, badly. Under it, listing any preset kept
+* `@bamboocss/preset-base` and silently dropped `@bamboocss/preset-bamboo`, so `presets`
+* was neither additive nor replacing, and `presets: []` meant "base only" rather than
+* "none". Both of those had to be discovered by reading this function.
 */
 async function resolveConfig(result, cwd) {
-	const presets = /* @__PURE__ */ new Set();
-	if (!result.config.eject) presets.add(_bamboocss_preset_base.preset);
-	if (result.config.presets) result.config.presets.forEach((preset) => {
-		presets.add(getBundledPreset(preset) ?? preset);
-	});
-	else if (!result.config.eject) presets.add(_bamboocss_preset_bamboo.preset);
-	result.config.presets = Array.from(presets);
-	const userConfig = result.config;
-	const pluginHooks = userConfig.plugins ?? [];
-	if (userConfig.hooks) pluginHooks.push({
-		name: _bamboocss_shared.BAMBOO_CONFIG_NAME,
-		hooks: userConfig.hooks
-	});
-	const earlyHooks = mergeHooks(pluginHooks);
-	const mergedConfig = await getResolvedConfig(result.config, cwd, earlyHooks);
-	const hooks = mergedConfig.hooks ?? {};
+	const listed = result.config.presets;
+	result.config.presets = listed ? Array.from(new Set(listed.map((preset) => getBundledPreset(preset) ?? preset))) : [...defaultPresets];
+	warnIfBaseDropped(listed, result.config.presets);
+	const hooks = mergeHooks(result.config.plugins ?? []);
+	const mergedConfig = await getResolvedConfig(result.config, cwd, hooks);
 	if (mergedConfig.logLevel) _bamboocss_logger.logger.level = mergedConfig.logLevel;
+	if (mergedConfig.logFilter) _bamboocss_logger.logger.filter = mergedConfig.logFilter;
 	validateConfig(mergedConfig);
 	const loadConfigResult = {
 		...result,
@@ -1015,6 +1244,7 @@ async function loadConfig(options) {
 //#endregion
 exports.bundleConfig = bundleConfig;
 exports.convertTsPathsToRegexes = convertTsPathsToRegexes;
+exports.defaultPresets = defaultPresets;
 exports.diffConfigs = diffConfigs;
 exports.findConfig = findConfig;
 exports.getConfigDependencies = getConfigDependencies;
@@ -1022,4 +1252,6 @@ exports.getResolvedConfig = getResolvedConfig;
 exports.loadConfig = loadConfig;
 exports.mergeConfigs = mergeConfigs;
 exports.mergeHooks = mergeHooks;
+exports.presetBamboo = _bamboocss_preset_bamboo.preset;
+exports.presetBase = _bamboocss_preset_base.preset;
 exports.resolveConfig = resolveConfig;