@tenphi/docs 0.17.0 → 0.18.0

package/dist/config-CD77r6rT.js

@@ -0,0 +1,2005 @@
+import { apcaContrast, contrastRatioFromLuminance, glaze, inferRoleFromName, normalizeRole, okhslToSrgb, oppositeRole, resolveContrastForLevel, variantToOkhsl } from "@tenphi/glaze";
+import { mergeStyles } from "@tenphi/tasty/core";
+//#region src/table-of-contents.ts
+function validateTableOfContents(value) {
+	if (value === false) return [];
+	if (!value || typeof value !== "object" || Array.isArray(value)) return ["tableOfContents must be false or an object."];
+	const config = value;
+	const errors = [];
+	for (const key of Object.keys(config)) if (![
+		"minHeadingLevel",
+		"maxHeadingLevel",
+		"mobile"
+	].includes(key)) errors.push(`tableOfContents.${key} is not supported.`);
+	for (const key of ["minHeadingLevel", "maxHeadingLevel"]) if (config[key] !== void 0 && (!Number.isInteger(config[key]) || Number(config[key]) < 1 || Number(config[key]) > 6)) errors.push(`tableOfContents.${key} must be an integer from 1 to 6.`);
+	if (config.mobile !== void 0 && typeof config.mobile !== "boolean") errors.push("tableOfContents.mobile must be a boolean.");
+	if (typeof config.minHeadingLevel === "number" && typeof config.maxHeadingLevel === "number" && config.minHeadingLevel > config.maxHeadingLevel) errors.push("tableOfContents.minHeadingLevel cannot exceed maxHeadingLevel.");
+	return errors;
+}
+//#endregion
+//#region src/publishing.ts
+function routeUrl(route, base = "/", site) {
+	const path = `${base.replace(/\/$/, "")}${route === "/" ? "/" : `${route}/`}`;
+	return site ? new URL(path, site).href : path;
+}
+/** Version roots follow any locale prefix, e.g. /fr/v1/guide. */
+function routeVersion(route, config) {
+	const first = route.split("/")[1];
+	const path = first && first !== "root" && config.locales?.[first] ? route.slice(first.length + 1) || "/" : route;
+	return [...config.site?.versions ?? []].sort((a, b) => b.routeBase.length - a.routeBase.length).find((v) => v.routeBase === "/" || path === v.routeBase || path.startsWith(`${v.routeBase}/`));
+}
+function pagePublishing(entry, config) {
+	const seo = config.site?.seo;
+	const page = entry.frontmatter.seo;
+	const version = routeVersion(entry.route, config);
+	const index = !entry.frontmatter.draft && seo?.index !== false && version?.index !== false && page?.index !== false;
+	const url = routeUrl(entry.route, config.build?.base, config.site?.url);
+	const canonical = page?.canonical ?? url;
+	const siteTitle = config.site?.title ?? "Documentation";
+	const title = page?.title ?? (seo?.titleTemplate ? seo.titleTemplate.replaceAll("{title}", entry.title).replaceAll("{site}", siteTitle) : entry.title === siteTitle ? entry.title : `${entry.title} | ${siteTitle}`);
+	return {
+		index,
+		sitemap: index && canonical === url,
+		canonical,
+		title,
+		version,
+		image: page?.image ?? seo?.image
+	};
+}
+function validateSeo(value, kind) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return ["seo must be an object."];
+	const seo = value;
+	const errors = [];
+	const allowed = kind === "site" ? [
+		"titleTemplate",
+		"image",
+		"index",
+		"breadcrumbs",
+		"copyPage"
+	] : [
+		"title",
+		"canonical",
+		"image",
+		"index",
+		"breadcrumbs"
+	];
+	for (const key of Object.keys(seo)) if (!allowed.includes(key)) errors.push(`seo.${key} is not supported.`);
+	for (const key of ["index", "copyPage"]) if (seo[key] !== void 0 && typeof seo[key] !== "boolean") errors.push(`seo.${key} must be a boolean.`);
+	if (seo.title !== void 0 && (typeof seo.title !== "string" || !seo.title.trim())) errors.push("seo.title must be non-empty text.");
+	if (seo.titleTemplate !== void 0 && (typeof seo.titleTemplate !== "string" || !seo.titleTemplate.includes("{title}") || /\{(?!title\}|site\})[^}]*\}/.test(seo.titleTemplate))) errors.push("seo.titleTemplate must include {title} and may include {site}; other placeholders are not supported.");
+	if (seo.canonical !== void 0 && !absoluteUrl(seo.canonical)) errors.push("seo.canonical must be an absolute HTTP(S) URL without credentials or a fragment.");
+	if (seo.image !== void 0 && seo.image !== false) {
+		const image = seo.image;
+		if (!image || typeof image !== "object" || Array.isArray(image)) errors.push("seo.image must be false or {src, alt, width?, height?}.");
+		else {
+			const img = image;
+			for (const key of Object.keys(img)) if (![
+				"src",
+				"alt",
+				"width",
+				"height"
+			].includes(key)) errors.push(`seo.image.${key} is not supported.`);
+			if (!absoluteUrl(img.src) && !(typeof img.src === "string" && /^\/(?!\/)[^\\\s?#]+$/.test(img.src) && !img.src.split("/").some((x) => x === ".." || x === "."))) errors.push("seo.image.src must be an HTTP(S) URL or root-relative public asset path.");
+			if (typeof img.alt !== "string" || !img.alt.trim()) errors.push("seo.image.alt must be non-empty text.");
+			for (const key of ["width", "height"]) if (img[key] !== void 0 && (!Number.isInteger(img[key]) || Number(img[key]) <= 0)) errors.push(`seo.image.${key} must be a positive integer.`);
+			if (img.width === void 0 !== (img.height === void 0)) errors.push("seo.image requires both width and height when dimensions are provided.");
+		}
+	}
+	if (seo.breadcrumbs !== void 0) {
+		if (kind === "site") {
+			if (typeof seo.breadcrumbs !== "boolean") errors.push("seo.breadcrumbs must be a boolean.");
+		} else if (seo.breadcrumbs !== false) {
+			if (!Array.isArray(seo.breadcrumbs) || seo.breadcrumbs.length < 2) errors.push("seo.breadcrumbs must be false or at least two {name, url} items.");
+			else for (const item of seo.breadcrumbs) if (!item || typeof item !== "object" || Object.keys(item).some((k) => k !== "name" && k !== "url") || typeof item.name !== "string" || !item.name.trim() || !absoluteUrl(item.url)) errors.push("Each seo.breadcrumbs item needs a name and absolute HTTP(S) url.");
+		}
+	}
+	return errors;
+}
+function absoluteUrl(value) {
+	if (typeof value !== "string" || /[\s\\]/.test(value)) return false;
+	try {
+		const u = new URL(value);
+		return /^https?:$/.test(u.protocol) && !u.hash && !u.username && !u.password;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/theme/contrast.ts
+const COLOR_MODES = [
+	"light",
+	"dark",
+	"lightContrast",
+	"darkContrast"
+];
+function rgb(color) {
+	const { h, s, l } = variantToOkhsl(color);
+	return okhslToSrgb(h, s, l, color.pastel);
+}
+function composite(foreground, background) {
+	const alpha = foreground.alpha ?? 1;
+	return rgb(foreground).map((channel, i) => channel * alpha + background[i] * (1 - alpha));
+}
+function luminance(channels, metric) {
+	return channels.reduce((sum, channel, i) => sum + [
+		.2126,
+		.7152,
+		.0722
+	][i] * (metric === "apca" ? channel ** 2.4 : channel <= .04045 ? channel / 12.92 : ((channel + .055) / 1.055) ** 2.4), 0);
+}
+function measureColorContrast(foreground, background, metric = "apca", underlay = background) {
+	const bg = composite(background, rgb(underlay));
+	const yForeground = luminance(composite(foreground, bg), metric);
+	const yBackground = luminance(bg, metric);
+	return metric === "apca" ? Math.abs(apcaContrast(yForeground, yBackground)) : contrastRatioFromLuminance(yForeground, yBackground);
+}
+function checkColorContrast(colors, definitions, level, brandTargets, inferRole = true) {
+	const pairs = /* @__PURE__ */ new Map();
+	const add = (foreground, background, spec) => {
+		const metric = resolveContrastForLevel(spec, 0).metric;
+		const key = `${foreground}/${background}/${metric}`;
+		const existing = pairs.get(key);
+		if (!existing) pairs.set(key, {
+			foreground,
+			background,
+			spec
+		});
+		else {
+			const targets = [0, 100].map((value) => Math.max(resolveContrastForLevel(spec, value).target, resolveContrastForLevel(existing.spec, value).target));
+			existing.spec = metric === "apca" ? { apca: targets } : { wcag: targets };
+		}
+	};
+	const roles = /* @__PURE__ */ new Map();
+	function role(name) {
+		const cached = roles.get(name);
+		if (cached) return cached;
+		const definition = definitions[name];
+		const explicit = "role" in definition ? normalizeRole(definition.role) : void 0;
+		const inferred = inferRole ? inferRoleFromName(name) : void 0;
+		const value = explicit ?? inferred ?? ("base" in definition && definition.base ? oppositeRole(role(definition.base)) : "text");
+		roles.set(name, value);
+		return value;
+	}
+	for (const [name, definition] of Object.entries(definitions)) {
+		if ("type" in definition || !definition.base || !definition.contrast) continue;
+		const isSurface = role(name) === "surface";
+		add(isSurface ? definition.base : name, isSurface ? name : definition.base, definition.contrast);
+	}
+	for (const role of [
+		"text",
+		"heading",
+		"text-soft"
+	]) add(role, "surface", { wcag: [4.5, 7] });
+	add("accent-text", "surface", { apca: brandTargets });
+	for (const background of [
+		"surface",
+		"surface-2",
+		"surface-3",
+		"accent-surface-subtle",
+		"accent-surface-2-subtle"
+	]) add("accent-text", background, { wcag: [4.5, 7] });
+	add("accent-surface-text", "accent-surface", { wcag: [4.5, 7] });
+	add("accent-surface-text", "accent-surface", { apca: [60, 75] });
+	add("logo-mark", "logo-surface", { wcag: [3, 4.5] });
+	for (const background of [
+		"surface",
+		"surface-2",
+		"surface-3"
+	]) add("focus", background, { wcag: [3, 4.5] });
+	for (const role of [
+		"info",
+		"success",
+		"warning",
+		"danger",
+		"orange",
+		"green",
+		"blue",
+		"purple",
+		"red"
+	]) {
+		add(`${role}-text`, `${role}-surface`, { apca: [60, 75] });
+		add(`${role}-text`, `${role}-surface`, { wcag: [4.5, 7] });
+	}
+	const checks = [];
+	const diagnostics = [];
+	for (const { foreground, background, spec } of pairs.values()) for (const mode of COLOR_MODES) {
+		const { metric, target } = resolveContrastForLevel(spec, mode.includes("Contrast") ? 100 : typeof level === "number" ? level : 0);
+		const measured = measureColorContrast(colors.get(foreground)[mode], colors.get(background)[mode], metric, colors.get("surface")[mode]);
+		const passed = measured + (metric === "apca" ? .05 : .01) >= target;
+		checks.push({
+			foreground,
+			background,
+			mode,
+			metric,
+			target,
+			measured,
+			passed
+		});
+		if (!passed) diagnostics.push({
+			code: foreground === "accent-text" && background === "surface" ? "DOCS_BRAND_CONTRAST_UNMET" : "DOCS_SEMANTIC_CONTRAST_UNMET",
+			severity: "error",
+			message: `${foreground} on ${background} in ${mode}: ${metric === "apca" ? "APCA Lc" : "WCAG ratio"} ${measured.toFixed(2)}; required ${target}.`,
+			hint: `Adjust theme.palette["${foreground}"] or theme.palette["${background}"] using tone, saturation, base, contrast, and autoFlip. Keep their contrast floor; a fixed mid-tone background may need to adapt. Also check theme.glaze tone boundaries and opacity.`
+		});
+	}
+	return {
+		checks,
+		diagnostics
+	};
+}
+//#endregion
+//#region src/theme/palette.ts
+function resolveColorTheme(theme = {}) {
+	const brand = normalizeBrand(theme.brand);
+	const authoredTarget = brand.contrast?.apca ?? 45;
+	const normalTarget = Array.isArray(authoredTarget) ? authoredTarget[0] : authoredTarget;
+	const highTarget = Array.isArray(authoredTarget) ? authoredTarget[1] : normalTarget + 15;
+	const glazeOptions = {
+		autoFlip: true,
+		...theme.glaze,
+		...theme.contrastLevel !== void 0 ? { contrastLevel: theme.contrastLevel } : {}
+	};
+	const surfaceInput = theme.palette?.surface;
+	const declaredSurface = isColorDeclaration(surfaceInput) && usesRelativeColor(surfaceInput);
+	const surfaceFrom = isColorDeclaration(surfaceInput) ? surfaceInput.from ?? brand.from : isSpecialDefinition(surfaceInput) ? "#ffffff" : surfaceInput ?? "#ffffff";
+	const resolvedSurfaceSeed = glaze.color({
+		from: surfaceFrom,
+		mode: "auto",
+		darkSaturation: .35
+	}).resolve();
+	const resolvedThemeSeed = glaze.color({
+		from: brand.from,
+		mode: "auto"
+	}, glazeOptions).resolve();
+	const lightThemeSeed = variantToOkhsl(resolvedThemeSeed.light);
+	const darkThemeSeed = variantToOkhsl(resolvedThemeSeed.dark);
+	const darkThemeSaturation = darkThemeSeed.s * 100;
+	const colorTheme = glaze({
+		hue: lightThemeSeed.h,
+		saturation: lightThemeSeed.s * 100,
+		darkHue: darkThemeSeed.h,
+		darkSaturation: darkThemeSaturation
+	}, void 0, glazeOptions);
+	const surfaceSaturation = declaredSurface ? surfaceInput.saturation ?? .05 : 1;
+	const darkSurfaceSaturation = declaredSurface ? surfaceInput.darkSaturation ?? surfaceSaturation * .7 : .35;
+	const darkSurfaceRampSaturation = (factor) => declaredSurface ? darkSurfaceSaturation * factor : saturationFactor(resolvedSurfaceSeed.dark.s * factor / .35, darkThemeSaturation / 100);
+	const surfaceRampHue = declaredSurface ? {
+		hue: surfaceInput.hue ?? lightThemeSeed.h,
+		darkHue: surfaceInput.darkHue ?? surfaceInput.hue ?? darkThemeSeed.h
+	} : {
+		hue: variantToOkhsl(resolvedSurfaceSeed.light).h,
+		darkHue: variantToOkhsl(resolvedSurfaceSeed.dark).h
+	};
+	const surfaceDefinition = paletteDefinition(surfaceInput, declaredSurface ? {
+		tone: 98,
+		saturation: surfaceSaturation,
+		darkSaturation: darkSurfaceSaturation,
+		mode: "auto"
+	} : {
+		from: surfaceFrom,
+		mode: "auto",
+		darkSaturation: saturationFactor(resolvedSurfaceSeed.dark.s, darkThemeSaturation / 100)
+	});
+	const definitions = {
+		surface: surfaceDefinition,
+		header: paletteDefinition(theme.palette?.header, declaredSurface ? {
+			...surfaceDefinition,
+			opacity: .7
+		} : {
+			from: surfaceFrom,
+			mode: "auto",
+			darkSaturation: saturationFactor(resolvedSurfaceSeed.dark.s, darkThemeSaturation / 100),
+			opacity: .7
+		}),
+		"surface-2": {
+			base: "surface",
+			...surfaceRampHue,
+			tone: "-2",
+			mode: "auto",
+			...declaredSurface ? { saturation: surfaceSaturation * .75 } : { from: {
+				h: variantToOkhsl(resolvedSurfaceSeed.light).h,
+				s: resolvedSurfaceSeed.light.s * .75,
+				t: 1
+			} },
+			darkSaturation: darkSurfaceRampSaturation(declaredSurface ? .75 : .275)
+		},
+		"surface-3": {
+			base: "surface-2",
+			...surfaceRampHue,
+			tone: "-2",
+			mode: "auto",
+			...declaredSurface ? { saturation: surfaceSaturation * .65 } : { from: {
+				h: variantToOkhsl(resolvedSurfaceSeed.light).h,
+				s: resolvedSurfaceSeed.light.s * .65,
+				t: 1
+			} },
+			darkSaturation: darkSurfaceRampSaturation(declaredSurface ? .65 : .25)
+		},
+		text: paletteDefinition(theme.palette?.text, {
+			tone: 0,
+			saturation: 0,
+			base: "surface",
+			role: "text",
+			contrast: { apca: [75, 90] },
+			mode: "auto"
+		}),
+		heading: paletteDefinition(theme.palette?.heading ?? theme.palette?.text, {
+			tone: [4, 0],
+			saturation: 0,
+			base: "surface",
+			role: "text",
+			contrast: { apca: [75, 90] },
+			mode: "auto"
+		}),
+		"text-soft": paletteDefinition(theme.palette?.textSoft, {
+			from: "#626875",
+			base: "surface",
+			role: "text",
+			contrast: { apca: [60, 85] },
+			mode: "auto"
+		}),
+		"text-muted": mix("surface", "text", 66),
+		"surface-2-hover": mix("surface-2", "text", [3, 6]),
+		"surface-2-pressed": mix("surface-2", "text", [9, 14]),
+		"surface-3-hover": mix("surface-3", "text", [3, 6]),
+		"surface-3-pressed": mix("surface-3", "text", [9, 14]),
+		"accent-text": {
+			from: brand.from,
+			base: "surface-3",
+			role: "text",
+			contrast: { apca: [Math.max(75, normalTarget), Math.max(90, highTarget)] },
+			mode: "auto"
+		},
+		focus: {
+			from: brand.from,
+			base: "surface-3",
+			role: "border",
+			contrast: { wcag: [3, 4.5] },
+			mode: "auto"
+		},
+		"accent-surface": {
+			from: brand.from,
+			base: "surface",
+			role: "text",
+			contrast: { apca: [75, 90] },
+			mode: "auto"
+		},
+		"accent-surface-text": {
+			from: "#ffffff",
+			base: "accent-surface",
+			role: "text",
+			contrast: { apca: [75, 90] },
+			mode: "auto"
+		},
+		"logo-surface": {
+			from: brand.from,
+			base: "logo-mark",
+			role: "surface",
+			contrast: { wcag: [3, 4.5] },
+			mode: "fixed"
+		},
+		"logo-mark": {
+			tone: 100,
+			saturation: 0,
+			mode: "fixed"
+		},
+		"accent-surface-subtle": mix("surface", "accent-surface", [12, 18]),
+		"accent-surface-2-subtle": mix("surface-2", "accent-surface", [12, 18]),
+		shadow: {
+			type: "shadow",
+			bg: "surface",
+			fg: "text",
+			intensity: [12, 20],
+			tuning: { alphaMax: theme.glaze?.shadowTuning?.alphaMax ?? .28 }
+		},
+		clear: {
+			from: "#ffffff",
+			mode: "fixed",
+			opacity: 0
+		},
+		...statusColors("info", theme.palette?.info, "#2563eb"),
+		...statusColors("success", theme.palette?.success, "#16a34a"),
+		...statusColors("warning", theme.palette?.warning, "#d97706"),
+		...statusColors("danger", theme.palette?.danger, "#dc2626"),
+		...statusColors("orange", void 0, "#d97706"),
+		...statusColors("green", void 0, "#16a34a"),
+		...statusColors("blue", void 0, "#2563eb"),
+		...statusColors("purple", void 0, "#9333ea"),
+		...statusColors("red", void 0, "#dc2626")
+	};
+	definitions.overlay = paletteDefinition(theme.palette?.overlay, {
+		from: "#000000",
+		mode: "static",
+		opacity: .5
+	});
+	definitions.border = {
+		base: "surface",
+		tone: ["-9", "-22"],
+		saturation: .205,
+		mode: "auto"
+	};
+	definitions["border-strong"] = {
+		base: "surface",
+		tone: ["-20", "-38"],
+		saturation: .205,
+		mode: "auto"
+	};
+	definitions["syntax-bg"] = { from: {
+		h: 210,
+		s: .09,
+		t: 1
+	} };
+	definitions["syntax-text"] = {
+		base: "syntax-bg",
+		tone: 0,
+		saturation: 0,
+		contrast: { wcag: ["AA", "AAA"] }
+	};
+	for (const [name, hue, saturation, contrast] of [
+		[
+			"comment",
+			210,
+			.009,
+			4.5
+		],
+		[
+			"punctuation",
+			210,
+			.009,
+			6
+		],
+		[
+			"keyword",
+			210,
+			.9,
+			4.5
+		],
+		[
+			"string",
+			40,
+			.9,
+			4.5
+		],
+		[
+			"token",
+			125,
+			.9,
+			4.5
+		],
+		[
+			"property",
+			155,
+			.9,
+			4.5
+		],
+		[
+			"number",
+			70,
+			.9,
+			4.5
+		],
+		[
+			"function",
+			210,
+			.9,
+			4.5
+		],
+		[
+			"value",
+			210,
+			.9,
+			4.5
+		],
+		[
+			"operator",
+			340,
+			.9,
+			4.5
+		]
+	]) definitions[`syntax-${name}`] = {
+		from: {
+			h: hue,
+			s: saturation,
+			t: 1
+		},
+		base: "syntax-bg",
+		contrast: { wcag: [contrast, 7] }
+	};
+	const handled = /* @__PURE__ */ new Set([
+		"surface",
+		"header",
+		"overlay",
+		"text",
+		"heading",
+		"textSoft",
+		"info",
+		"success",
+		"warning",
+		"danger"
+	]);
+	const names = /* @__PURE__ */ new Set();
+	for (const [name, input] of Object.entries(theme.palette ?? {})) {
+		if (input === void 0) continue;
+		const canonical = name === "textSoft" ? "text-soft" : name;
+		if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(canonical) || [
+			"current",
+			"constructor",
+			"prototype"
+		].includes(canonical)) throw new Error(`theme.palette.${name}: use a lowercase color name with hyphens; current, constructor, and prototype are reserved.`);
+		if (names.has(canonical)) throw new Error(`theme.palette.${name}: duplicates the ${canonical} color role (textSoft is an alias of text-soft).`);
+		names.add(canonical);
+		if (handled.has(name)) continue;
+		const defaults = definitions[canonical];
+		definitions[canonical] = paletteDefinition(input, defaults ?? { mode: "auto" });
+	}
+	for (const definition of Object.values(definitions)) {
+		if ("base" in definition && definition.base === "textSoft") definition.base = "text-soft";
+		if ("target" in definition && definition.target === "textSoft") definition.target = "text-soft";
+		if ("bg" in definition && definition.bg === "textSoft") definition.bg = "text-soft";
+		if ("fg" in definition && definition.fg === "textSoft") definition.fg = "text-soft";
+	}
+	colorTheme.colors(definitions);
+	const resolvedColors = colorTheme.resolve();
+	const resolvedSurface = requiredResolvedColor(resolvedColors, "surface");
+	const resolvedAccent = requiredResolvedColor(resolvedColors, "accent-text");
+	const scores = {
+		light: measureColorContrast(resolvedAccent.light, resolvedSurface.light),
+		dark: measureColorContrast(resolvedAccent.dark, resolvedSurface.dark),
+		lightContrast: measureColorContrast(resolvedAccent.lightContrast, resolvedSurface.lightContrast),
+		darkContrast: measureColorContrast(resolvedAccent.darkContrast, resolvedSurface.darkContrast)
+	};
+	const { checks: contrastChecks, diagnostics } = checkColorContrast(resolvedColors, definitions, theme.contrastLevel, [normalTarget, highTarget], theme.glaze?.inferRole);
+	const outputOptions = { modes: { highContrast: true } };
+	const tastyOptions = {
+		...outputOptions,
+		states: {
+			dark: "theme=dark | (@media(prefers-color-scheme: dark) & :not([data-theme]))",
+			highContrast: "contrast=more | (@media(prefers-contrast: more) & :not([data-contrast]))"
+		}
+	};
+	const resolvedPalette = colorTheme.json(outputOptions);
+	const colorTokens = colorTheme.tasty(tastyOptions);
+	return {
+		colors: {
+			surface: requiredJsonColor(resolvedPalette, "surface"),
+			surface2: requiredJsonColor(resolvedPalette, "surface-2"),
+			surface3: requiredJsonColor(resolvedPalette, "surface-3"),
+			text: requiredJsonColor(resolvedPalette, "text"),
+			heading: requiredJsonColor(resolvedPalette, "heading"),
+			textSoft: requiredJsonColor(resolvedPalette, "text-soft"),
+			accentText: requiredJsonColor(resolvedPalette, "accent-text"),
+			accentSurface: requiredJsonColor(resolvedPalette, "accent-surface"),
+			accentSurfaceText: requiredJsonColor(resolvedPalette, "accent-surface-text"),
+			focus: requiredJsonColor(resolvedPalette, "focus"),
+			shadow: requiredJsonColor(resolvedPalette, "shadow")
+		},
+		colorTokens,
+		contrast: scores,
+		contrastChecks,
+		diagnostics
+	};
+}
+function mix(base, target, value, space = "okhsl") {
+	return {
+		type: "mix",
+		base,
+		target,
+		value,
+		space
+	};
+}
+function statusColors(name, input, fallback) {
+	const declaration = paletteDefinition(input, { from: fallback });
+	return {
+		[name]: isSpecialDefinition(declaration) ? declaration : {
+			base: "surface",
+			role: "border",
+			contrast: { apca: [30, 45] },
+			mode: "auto",
+			...declaration
+		},
+		[`${name}-text`]: {
+			...isSpecialDefinition(declaration) ? {
+				tone: 0,
+				saturation: 0
+			} : declaration,
+			base: `${name}-surface`,
+			role: "text",
+			contrast: { apca: [75, 90] },
+			mode: "auto"
+		},
+		[`${name}-surface`]: "type" in declaration && declaration.type === "shadow" ? {
+			base: "surface",
+			tone: "-2",
+			saturation: 0,
+			mode: "auto"
+		} : mix("surface", name, [12, 18], "srgb")
+	};
+}
+function isSpecialDefinition(value) {
+	return typeof value === "object" && value !== null && "type" in value;
+}
+function isColorDeclaration(value) {
+	return typeof value === "object" && value !== null && !("h" in value || "r" in value || "c" in value || "type" in value);
+}
+function paletteDefinition(value, baseDefaults) {
+	if (value === void 0) return baseDefaults;
+	if (isSpecialDefinition(value)) return { ...value };
+	const defaults = "type" in baseDefaults ? { mode: "auto" } : baseDefaults;
+	if (!isColorDeclaration(value) || value.from !== void 0) {
+		const { tone: _tone, saturation: _saturation, ...seedDefaults } = defaults;
+		return {
+			...seedDefaults,
+			...isColorDeclaration(value) ? value : { from: value }
+		};
+	}
+	if (!usesRelativeColor(value)) return {
+		...defaults,
+		...value
+	};
+	const { from: _ignored, ...relativeDefaults } = defaults;
+	return {
+		...relativeDefaults,
+		...value
+	};
+}
+function usesRelativeColor(value) {
+	return value.from === void 0 && (value.tone !== void 0 || value.hue !== void 0 || value.darkHue !== void 0 || value.saturation !== void 0 || value.darkSaturation !== void 0 || value.base !== void 0);
+}
+function saturationFactor(colorSaturation, themeSaturation) {
+	return themeSaturation > 0 ? Math.min(1, colorSaturation / themeSaturation) : 0;
+}
+function requiredResolvedColor(colors, name) {
+	const color = colors.get(name);
+	if (!color) throw new Error(`The Glaze ${name} color failed to resolve.`);
+	return color;
+}
+function requiredJsonColor(colors, name) {
+	const color = colors[name];
+	if (!color) throw new Error(`The Glaze ${name} token failed to export.`);
+	return color;
+}
+function normalizeBrand(brand) {
+	if (typeof brand === "object" && brand !== null && "from" in brand) return brand;
+	if (isBrandDeclaration$1(brand)) {
+		const seed = glaze.color({
+			hue: brand.hue,
+			saturation: brand.saturation,
+			tone: brand.tone,
+			mode: "fixed"
+		}).resolve().light;
+		return {
+			from: {
+				h: seed.h,
+				s: seed.s,
+				t: seed.t
+			},
+			...brand.contrast && { contrast: brand.contrast },
+			...brand.unsafeContrast && { unsafeContrast: true }
+		};
+	}
+	return { from: brand ?? "okhsl(266 68% 48%)" };
+}
+function isBrandDeclaration$1(brand) {
+	return typeof brand === "object" && brand !== null && "hue" in brand && "saturation" in brand && "tone" in brand;
+}
+//#endregion
+//#region src/types.ts
+const COOKBOOK_PALETTE_NAMES = [
+	"surface",
+	"header",
+	"surface-2",
+	"surface-3",
+	"text",
+	"heading",
+	"text-soft",
+	"text-muted",
+	"surface-2-hover",
+	"surface-2-pressed",
+	"surface-3-hover",
+	"surface-3-pressed",
+	"accent-text",
+	"focus",
+	"accent-surface",
+	"accent-surface-text",
+	"logo-surface",
+	"logo-mark",
+	"accent-surface-subtle",
+	"accent-surface-2-subtle",
+	"shadow",
+	"clear",
+	"info",
+	"info-text",
+	"info-surface",
+	"success",
+	"success-text",
+	"success-surface",
+	"warning",
+	"warning-text",
+	"warning-surface",
+	"danger",
+	"danger-text",
+	"danger-surface",
+	"orange",
+	"orange-text",
+	"orange-surface",
+	"green",
+	"green-text",
+	"green-surface",
+	"blue",
+	"blue-text",
+	"blue-surface",
+	"purple",
+	"purple-text",
+	"purple-surface",
+	"red",
+	"red-text",
+	"red-surface",
+	"overlay",
+	"border",
+	"border-strong",
+	"syntax-bg",
+	"syntax-text",
+	"syntax-comment",
+	"syntax-punctuation",
+	"syntax-keyword",
+	"syntax-string",
+	"syntax-token",
+	"syntax-property",
+	"syntax-number",
+	"syntax-function",
+	"syntax-value",
+	"syntax-operator"
+];
+/** Cookbook UI surfaces whose default Tasty styles can be customized. */
+const COOKBOOK_COMPONENT_NAMES = [
+	"Card",
+	"Callout",
+	"CodeGroup",
+	"Tab",
+	"Footer",
+	"PageActions",
+	"MobileTableOfContents",
+	"Hero",
+	"PageFrame",
+	"HeaderFrame",
+	"HeaderLinks",
+	"Heading",
+	"Layout",
+	"SearchButton",
+	"TableOfContentsLayout",
+	"LanguageSelect",
+	"Logo",
+	"SiteLogo",
+	"MarkdownCodeBlock",
+	"MarkdownHeading",
+	"MarkdownInlineCode",
+	"MarkdownTable",
+	"Mermaid",
+	"MobileMenuFooter",
+	"MobileMenuToggle",
+	"MobileNavigationTabs",
+	"PackageVersion",
+	"VersionSwitcher",
+	"Preview",
+	"Sidebar",
+	"SocialIcons",
+	"Steps",
+	"Tabs",
+	"TableOfContents",
+	"ThemeSelect",
+	"TopNavigation",
+	"StarlightHeader",
+	"Document",
+	"MainPane",
+	"MainContent",
+	"Banner",
+	"SkipLink",
+	"Search",
+	"Pagination",
+	"Markdown",
+	"MermaidSource",
+	"StarlightAside",
+	"StarlightCard",
+	"StarlightLinkCard",
+	"StarlightBadge",
+	"StarlightSteps",
+	"SearchResults",
+	"SyntaxHighlight"
+];
+/** Named Tasty sub-elements available on each configurable Cookbook surface. */
+const COOKBOOK_COMPONENT_SUB_ELEMENTS = {
+	SyntaxHighlight: [
+		"Scroll",
+		"Wrap",
+		"Marker",
+		"Comment",
+		"Punctuation",
+		"Keyword",
+		"String",
+		"Token",
+		"Property",
+		"Number",
+		"Function",
+		"Value",
+		"Operator",
+		"Text",
+		"Bg",
+		"Inserted",
+		"Deleted",
+		"Italic",
+		"Strong",
+		"Underline"
+	],
+	SearchResults: [
+		"Form",
+		"Input",
+		"Clear",
+		"Results",
+		"Result",
+		"ResultLink",
+		"SearchIcon",
+		"ClearIcon",
+		"SuppressedClear",
+		"Message",
+		"List",
+		"Title",
+		"Excerpt",
+		"NestedResult",
+		"Match",
+		"More",
+		"HoverMore"
+	],
+	StarlightSteps: [
+		"Item",
+		"Counter",
+		"Connector"
+	],
+	StarlightBadge: [],
+	StarlightLinkCard: [
+		"Hover",
+		"Stack",
+		"Link",
+		"LinkOverlay",
+		"DescriptionAndIcon"
+	],
+	StarlightCard: ["Title"],
+	StarlightAside: [
+		"Note",
+		"Tip",
+		"Caution",
+		"Danger",
+		"Title",
+		"Icon",
+		"FirstContent"
+	],
+	MermaidSource: [],
+	Markdown: [
+		"Block",
+		"BlockSpacing",
+		"HeadingSpacing",
+		"List",
+		"CompactItem",
+		"ListItem",
+		"DefinitionTerm",
+		"DefinitionDescription",
+		"Link",
+		"HoverLink",
+		"Quote",
+		"Rule",
+		"Details",
+		"HoverDetails",
+		"Summary",
+		"OpenSummary",
+		"SummaryMarker",
+		"SummaryIcon",
+		"OpenSummaryIcon",
+		"Code"
+	],
+	Pagination: [
+		"Link",
+		"NextLink",
+		"NextIcon",
+		"NextLabel",
+		"HoverLink",
+		"ActiveLink",
+		"Title",
+		"LoneNextLink",
+		"NativeIcon",
+		"Icon",
+		"PreviousIconRtl",
+		"NextIconRtl"
+	],
+	Search: [
+		"Status",
+		"Dialog",
+		"CloseIcon",
+		"OpenDialog",
+		"Backdrop",
+		"Frame",
+		"Container",
+		"Close",
+		"HoverClose",
+		"ActiveClose"
+	],
+	SkipLink: ["Focus"],
+	Banner: ["Link"],
+	MainContent: [
+		"ContentSpacing",
+		"Container",
+		"Panel",
+		"FirstPanel",
+		"BodyPanel"
+	],
+	MainPane: ["WithSidebars"],
+	Document: [
+		"All",
+		"Body",
+		"Control",
+		"Pointer",
+		"ResponsiveWidth",
+		"ResponsiveHeight",
+		"Hidden",
+		"DesktopBlock",
+		"DesktopFlex",
+		"ScreenReaderOnly",
+		"Strong",
+		"Link",
+		"NarrowBlock",
+		"MobileBlock",
+		"Code",
+		"FocusRing",
+		"CurrentLink",
+		"SearchOpen"
+	],
+	PageFrame: [
+		"MainFrame",
+		"SidebarFrame",
+		"Columns"
+	],
+	HeaderFrame: [],
+	Heading: [
+		"Level1",
+		"Level2",
+		"Level3",
+		"Level4",
+		"Level5",
+		"Level6",
+		"PageTitle"
+	],
+	HeaderLinks: [
+		"Desktop",
+		"DesktopLink",
+		"Link",
+		"HoverLink",
+		"PrimaryLink",
+		"HoverPrimaryLink",
+		"Trigger",
+		"HoverTrigger",
+		"Panel",
+		"PanelNavigation",
+		"PanelLink",
+		"FirstPanelLink",
+		"Close",
+		"HoverClose"
+	],
+	Layout: [
+		"Islands",
+		"LockedPage",
+		"Light",
+		"Auto"
+	],
+	SearchButton: [
+		"PendingShortcut",
+		"Label",
+		"Shortcut",
+		"Hover",
+		"Active",
+		"NativeIcon",
+		"Icon"
+	],
+	TableOfContentsLayout: ["WithMobile", "Content"],
+	Card: [
+		"Heading2",
+		"Heading3",
+		"Paragraph"
+	],
+	Callout: [
+		"Title",
+		"Body",
+		"Tip",
+		"Caution",
+		"Danger"
+	],
+	CodeGroup: [
+		"Caption",
+		"Pre",
+		"Code"
+	],
+	Tab: [
+		"Heading",
+		"Hidden",
+		"HiddenHeading"
+	],
+	MobileTableOfContents: [
+		"Summary",
+		"List",
+		"NestedList",
+		"Item",
+		"Link",
+		"HoverLink",
+		"Focus"
+	],
+	PageActions: [
+		"Control",
+		"Hover",
+		"Focus",
+		"Pending",
+		"Status"
+	],
+	Footer: [
+		"Meta",
+		"LoneMetaItem",
+		"MetaLink",
+		"HoverMetaLink",
+		"Credit",
+		"CreditLink",
+		"HoverCreditLink"
+	],
+	Hero: [
+		"Visual",
+		"Stack",
+		"Copy",
+		"Title",
+		"Tagline",
+		"Actions",
+		"Action",
+		"HoverAction",
+		"PrimaryAction",
+		"SecondaryAction",
+		"MinimalAction",
+		"ActionIcon"
+	],
+	LanguageSelect: [
+		"Label",
+		"HoverLabel",
+		"LabelIcon",
+		"Select",
+		"Caret",
+		"Option"
+	],
+	Logo: ["Svg", "Mark"],
+	SiteLogo: [
+		"Image",
+		"Light",
+		"Dark"
+	],
+	MarkdownCodeBlock: [
+		"Pre",
+		"CopyButton",
+		"HoverCopyButton",
+		"CopiedButton",
+		"CopyIcon",
+		"CopiedIcon",
+		"Code",
+		"Diff",
+		"DiffCode",
+		"DiffLine",
+		"EmptyDiffLine",
+		"InsertedLine",
+		"DeletedLine"
+	],
+	MarkdownHeading: [
+		"Heading",
+		"Heading1",
+		"Heading2",
+		"Heading3",
+		"Heading4",
+		"Heading5",
+		"Heading6",
+		"Link",
+		"RevealedLink",
+		"HoverLink",
+		"LinkIcon",
+		"CopiedLink",
+		"CopiedLinkIcon",
+		"CopiedIcon"
+	],
+	MarkdownTable: [
+		"Table",
+		"Cell",
+		"LastBodyRowCell",
+		"HeaderCell",
+		"Scroll"
+	],
+	MarkdownInlineCode: [],
+	Mermaid: [
+		"Diagram",
+		"Text",
+		"MonoText"
+	],
+	MobileMenuFooter: ["Social"],
+	MobileMenuToggle: [
+		"Control",
+		"Icon",
+		"Section",
+		"Page",
+		"HoverControl",
+		"ActiveControl"
+	],
+	MobileNavigationTabs: [
+		"Trigger",
+		"Marker",
+		"Caret",
+		"ExpandedCaret",
+		"Label",
+		"List",
+		"Item",
+		"Link",
+		"HoverLink",
+		"CurrentLink"
+	],
+	PackageVersion: [],
+	VersionSwitcher: [
+		"Trigger",
+		"Panel",
+		"OpenPanel",
+		"Link",
+		"CurrentLink"
+	],
+	Preview: [
+		"Caption",
+		"Stage",
+		"Frame",
+		"Code",
+		"Summary",
+		"Pre"
+	],
+	Sidebar: [
+		"Backdrop",
+		"OpenBackdrop",
+		"MobileHeading",
+		"HomeLink",
+		"HomeLogo",
+		"HomeLabel",
+		"Close",
+		"HoverClose",
+		"CloseIcon",
+		"CurrentLink",
+		"OpenPane",
+		"EnteredPane",
+		"Content",
+		"Tree",
+		"List",
+		"Item",
+		"TopLevelSpacing",
+		"GroupSpacing",
+		"NestedItem",
+		"SectionHeading",
+		"Control",
+		"Summary",
+		"GroupLabel",
+		"GroupLabelText",
+		"Link",
+		"LinkLabel",
+		"InteractiveControl",
+		"SummaryMarker",
+		"Caret",
+		"ExpandedCaret",
+		"LinkedSummary",
+		"GroupLink",
+		"LinkedSectionHeading",
+		"SectionLink",
+		"Badge",
+		"TopLevelLink"
+	],
+	Steps: ["Item", "Marker"],
+	SocialIcons: [
+		"Link",
+		"HoverLink",
+		"Icon"
+	],
+	Tabs: [
+		"List",
+		"Button",
+		"SelectedButton",
+		"FocusedButton"
+	],
+	TableOfContents: [
+		"Heading",
+		"List",
+		"Item",
+		"Link",
+		"LinkLabel",
+		"HoverLink",
+		"CurrentLink"
+	],
+	ThemeSelect: [
+		"Trigger",
+		"HoverTrigger",
+		"ActiveTrigger",
+		"Icon",
+		"Panel",
+		"OpenPanel",
+		"Section",
+		"SectionSpacing",
+		"SectionLabel",
+		"Option",
+		"HoverOption",
+		"CheckedOption",
+		"FocusedOption",
+		"Input",
+		"OptionIcon",
+		"Checkmark",
+		"SelectedCheckmark"
+	],
+	TopNavigation: [
+		"Scrollbar",
+		"Link",
+		"HoverLink",
+		"CurrentLink",
+		"ActiveIndicator"
+	],
+	StarlightHeader: [
+		"Primary",
+		"TitleAndSearch",
+		"Title",
+		"LogoLink",
+		"Logo",
+		"SiteTitle",
+		"Search",
+		"SearchElement",
+		"Tools",
+		"ToolItem",
+		"Social",
+		"MobileTheme"
+	]
+};
+//#endregion
+//#region src/config/index.ts
+const DEFAULT_BRAND = "okhsl(266 68% 48%)";
+const HEAD_KEYS = /* @__PURE__ */ new Set([
+	"tag",
+	"attrs",
+	"content"
+]);
+const SITE_ICON_KEYS = /* @__PURE__ */ new Set(["source", "background"]);
+const COLOR_DECLARATION_KEYS = /* @__PURE__ */ new Set([
+	"from",
+	"tone",
+	"saturation",
+	"hue",
+	"darkHue",
+	"darkSaturation",
+	"base",
+	"contrast",
+	"mode",
+	"autoFlip",
+	"opacity",
+	"pastel",
+	"role",
+	"inherit"
+]);
+const ROOT_KEYS = /* @__PURE__ */ new Set([
+	"tableOfContents",
+	"root",
+	"redirects",
+	"site",
+	"head",
+	"editLink",
+	"lastUpdated",
+	"locales",
+	"translations",
+	"defaultLocale",
+	"content",
+	"navigation",
+	"theme",
+	"markdown",
+	"search",
+	"components",
+	"build"
+]);
+const OBJECT_KEYS = {
+	site: /* @__PURE__ */ new Set([
+		"seo",
+		"title",
+		"version",
+		"versions",
+		"description",
+		"url",
+		"repository",
+		"favicon",
+		"logo",
+		"headerLinks"
+	]),
+	content: /* @__PURE__ */ new Set([
+		"sources",
+		"allowOutsideRoot",
+		"localizeRepositoryLinks",
+		"frontmatter"
+	]),
+	markdown: /* @__PURE__ */ new Set(["stripLeadingBadges", "rawHtml"]),
+	search: /* @__PURE__ */ new Set(["enabled"]),
+	components: /* @__PURE__ */ new Set(["overrides"]),
+	theme: /* @__PURE__ */ new Set([
+		"brand",
+		"palette",
+		"glaze",
+		"units",
+		"recipes",
+		"fonts",
+		"fontLoading",
+		"states",
+		"tokens",
+		"presets",
+		"styles",
+		"customStyles",
+		"contrastLevel"
+	]),
+	build: /* @__PURE__ */ new Set([
+		"strict",
+		"ci",
+		"cacheDir",
+		"maxArtifactBytes",
+		"maxUnpackedBytes",
+		"maxFiles",
+		"maxPathDepth",
+		"maxAssetBytes"
+	])
+};
+var DocsConfigError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		super(diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+		this.name = "DocsConfigError";
+		this.diagnostics = diagnostics;
+	}
+};
+function validateConfig(config) {
+	const diagnostics = [];
+	if (config === null || typeof config !== "object" || Array.isArray(config)) {
+		invalid(diagnostics, "Documentation configuration must be an object.");
+		return diagnostics;
+	}
+	if (config.root !== void 0 && typeof config.root !== "string") invalid(diagnostics, "root must be a directory path.");
+	for (const key of Object.keys(config)) if (!ROOT_KEYS.has(key)) unknown(diagnostics, key);
+	for (const [section, keys] of Object.entries(OBJECT_KEYS)) {
+		const value = config[section];
+		if (value === void 0) continue;
+		if (!isRecord(value)) {
+			invalid(diagnostics, `${section} must be an object.`);
+			continue;
+		}
+		for (const key of Object.keys(value)) if (!keys.has(key)) unknown(diagnostics, `${section}.${key}`);
+	}
+	if (isRecord(config.site) && config.site.versions !== void 0) {
+		if (!Array.isArray(config.site.versions) || config.site.versions.length < 2) invalid(diagnostics, "site.versions must contain at least two versions.");
+		else {
+			const bases = /* @__PURE__ */ new Set();
+			for (const [index, version] of config.site.versions.entries()) {
+				const path = `site.versions[${index}]`;
+				if (!isRecord(version)) {
+					invalid(diagnostics, `${path} must be an object.`);
+					continue;
+				}
+				for (const key of Object.keys(version)) if (key !== "label" && key !== "routeBase" && key !== "index") unknown(diagnostics, `${path}.${key}`);
+				if (typeof version.label !== "string" || !version.label.trim()) invalid(diagnostics, `${path}.label must be a non-empty string.`);
+				if (version.index !== void 0 && typeof version.index !== "boolean") invalid(diagnostics, `${path}.index must be a boolean.`);
+				const base = version.routeBase;
+				if (typeof base !== "string" || !base.startsWith("/") || base !== "/" && base.endsWith("/") || base.includes("//") || /[?#\\\s]/.test(base) || base.split("/").some((segment) => segment === "." || segment === "..")) invalid(diagnostics, `${path}.routeBase must be a root-relative route without a trailing slash.`);
+				else if (bases.has(base)) invalid(diagnostics, `${path}.routeBase duplicates ${base}.`);
+				else bases.add(base);
+			}
+		}
+	}
+	if (isRecord(config.site) && config.site.headerLinks !== void 0) {
+		if (!Array.isArray(config.site.headerLinks)) invalid(diagnostics, "site.headerLinks must be an array.");
+		else config.site.headerLinks.forEach((item, index) => {
+			const path = `site.headerLinks[${index}]`;
+			if (!isRecord(item)) {
+				invalid(diagnostics, `${path} must be an object.`);
+				return;
+			}
+			for (const key of Object.keys(item)) if (![
+				"label",
+				"link",
+				"variant",
+				"newTab"
+			].includes(key)) unknown(diagnostics, `${path}.${key}`);
+			if (typeof item.label !== "string" || !item.label.trim()) invalid(diagnostics, `${path}.label must be a non-empty string.`);
+			if (typeof item.link !== "string" || /[\\\s]/.test(item.link) || !(/^(?:\/(?!\/)|#)/.test(item.link) || isHttpUrl(item.link))) invalid(diagnostics, `${path}.link must be an HTTP(S) URL, root-relative route, or fragment.`);
+			if (item.variant !== void 0 && !["default", "primary"].includes(item.variant)) invalid(diagnostics, `${path}.variant must be "default" or "primary".`);
+			if (item.newTab !== void 0 && typeof item.newTab !== "boolean") invalid(diagnostics, `${path}.newTab must be a boolean.`);
+		});
+	}
+	if (config.navigation !== void 0 && !Array.isArray(config.navigation)) {
+		if (!isRecord(config.navigation)) invalid(diagnostics, "navigation must be an array or object.");
+		else {
+			for (const key of Object.keys(config.navigation)) if (!(/* @__PURE__ */ new Set(["items", "tabs"])).has(key)) unknown(diagnostics, `navigation.${key}`);
+			if (config.navigation.items !== void 0 && !Array.isArray(config.navigation.items)) invalid(diagnostics, "navigation.items must be an array.");
+			if (config.navigation.tabs !== void 0 && !Array.isArray(config.navigation.tabs)) invalid(diagnostics, "navigation.tabs must be an array.");
+		}
+	}
+	if (Array.isArray(config.navigation)) validateNavigationItems(config.navigation, "navigation", diagnostics);
+	else if (isRecord(config.navigation)) {
+		if (Array.isArray(config.navigation.items)) validateNavigationItems(config.navigation.items, "navigation.items", diagnostics);
+		if (Array.isArray(config.navigation.tabs)) for (const [index, tab] of config.navigation.tabs.entries()) {
+			const path = `navigation.tabs[${index}]`;
+			if (!isRecord(tab) || typeof tab.label !== "string" || typeof tab.link !== "string") invalid(diagnostics, `${path} must have a label and link.`);
+			else if (tab.items !== void 0) validateNavigationItems(tab.items, `${path}.items`, diagnostics);
+		}
+	}
+	if (config.redirects !== void 0 && (!isRecord(config.redirects) || Object.values(config.redirects).some((value) => typeof value !== "string"))) invalid(diagnostics, "redirects must map old routes to document routes.");
+	const head = config.head;
+	if (head !== void 0 && !Array.isArray(head)) invalid(diagnostics, "head must be an array.");
+	else for (const [index, entry] of (head ?? []).entries()) {
+		if (!isRecord(entry)) {
+			invalid(diagnostics, `head[${index}] must be an object.`);
+			continue;
+		}
+		for (const key of Object.keys(entry)) if (!HEAD_KEYS.has(key)) unknown(diagnostics, `head[${index}].${key}`);
+		if (typeof entry.tag !== "string") invalid(diagnostics, `head[${index}].tag must be a string.`);
+		if (entry.attrs !== void 0 && !isRecord(entry.attrs)) invalid(diagnostics, `head[${index}].attrs must be an object.`);
+		else for (const [name, value] of Object.entries(entry.attrs ?? {})) if (value !== void 0 && typeof value !== "string" && typeof value !== "boolean") invalid(diagnostics, `head[${index}].attrs.${name} must be a string or boolean.`);
+		if (entry.content !== void 0 && typeof entry.content !== "string") invalid(diagnostics, `head[${index}].content must be a string.`);
+	}
+	if (config.site?.seo !== void 0) for (const message of validateSeo(config.site.seo, "site")) invalid(diagnostics, `site.${message}`);
+	if (config.tableOfContents !== void 0) for (const message of validateTableOfContents(config.tableOfContents)) invalid(diagnostics, message);
+	const logo = config.site?.logo;
+	if (logo !== void 0 && logo !== false) {
+		const value = typeof logo === "string" ? { src: logo } : logo;
+		if (!isRecord(value)) invalid(diagnostics, "site.logo must be false, a local image path, or a logo definition.");
+		else {
+			for (const key of Object.keys(value)) if (![
+				"src",
+				"light",
+				"dark",
+				"alt",
+				"href",
+				"width",
+				"height",
+				"decorative"
+			].includes(key)) unknown(diagnostics, `site.logo.${key}`);
+			if (value.src !== void 0 && (value.light !== void 0 || value.dark !== void 0) || value.src === void 0 && (value.light === void 0 || value.dark === void 0)) invalid(diagnostics, "site.logo must provide src or both light and dark paths.");
+			for (const key of [
+				"src",
+				"light",
+				"dark"
+			]) if (value[key] !== void 0 && (typeof value[key] !== "string" || !value[key].trim() || /^[a-z][a-z\d+.-]*:|^\/\//i.test(value[key]))) invalid(diagnostics, `site.logo.${key} must be a non-empty local image path.`);
+			if (value.href !== void 0 && (typeof value.href !== "string" || /[\\\s]/.test(value.href) || !(/^(?:\/(?!\/)|#)/.test(value.href) || isHttpUrl(value.href)))) invalid(diagnostics, "site.logo.href must be an HTTP(S) URL, root-relative route, or fragment.");
+			if (value.alt !== void 0 && typeof value.alt !== "string") invalid(diagnostics, "site.logo.alt must be a string.");
+			if (value.decorative !== void 0 && typeof value.decorative !== "boolean") invalid(diagnostics, "site.logo.decorative must be a boolean.");
+			for (const key of ["width", "height"]) if (value[key] !== void 0 && (typeof value[key] !== "number" || !Number.isFinite(value[key]) || value[key] <= 0)) invalid(diagnostics, `site.logo.${key} must be a positive dimension.`);
+		}
+	}
+	const favicon = config.site?.favicon;
+	if (favicon !== void 0) {
+		if (typeof favicon === "string") {
+			if (favicon.trim() === "") invalid(diagnostics, "site.favicon must be a non-empty local path.");
+		} else if (!isRecord(favicon)) invalid(diagnostics, "site.favicon must be a local path or an object with a source path.");
+		else {
+			for (const key of Object.keys(favicon)) if (!SITE_ICON_KEYS.has(key)) unknown(diagnostics, `site.favicon.${key}`);
+			if (typeof favicon.source !== "string" || favicon.source.trim() === "") invalid(diagnostics, "site.favicon.source must be a non-empty string.");
+			if (favicon.background !== void 0 && (typeof favicon.background !== "string" || favicon.background.trim() === "")) invalid(diagnostics, "site.favicon.background must be a non-empty color string.");
+		}
+	}
+	for (const field of ["url", "repository"]) {
+		const value = config.site?.[field];
+		if (value === void 0) continue;
+		if (typeof value !== "string" || !isHttpUrl(value)) invalid(diagnostics, `site.${field} must be an absolute HTTP(S) URL.`);
+	}
+	if (config.editLink !== void 0 && (!isRecord(config.editLink) || typeof config.editLink.baseUrl !== "string")) invalid(diagnostics, "editLink must contain a string baseUrl.");
+	else if (config.editLink !== void 0) {
+		for (const key of Object.keys(config.editLink)) if (key !== "baseUrl") unknown(diagnostics, `editLink.${key}`);
+		try {
+			new URL(config.editLink.baseUrl);
+		} catch {
+			invalid(diagnostics, "editLink.baseUrl must be an absolute URL.");
+		}
+	}
+	if (config.lastUpdated !== void 0 && typeof config.lastUpdated !== "boolean") invalid(diagnostics, "lastUpdated must be a boolean.");
+	if (config.translations !== void 0 && (!isRecord(config.translations) || Object.values(config.translations).some((messages) => !isRecord(messages) || Object.values(messages).some((value) => typeof value !== "string")))) invalid(diagnostics, "translations must map language codes to string messages.");
+	if (config.locales !== void 0 && !isRecord(config.locales)) invalid(diagnostics, "locales must be an object.");
+	else for (const [key, locale] of Object.entries(config.locales ?? {})) {
+		if (!isRecord(locale) || typeof locale.label !== "string") {
+			invalid(diagnostics, `locales.${key} must contain a string label.`);
+			continue;
+		}
+		for (const property of Object.keys(locale)) if (![
+			"label",
+			"lang",
+			"dir"
+		].includes(property)) unknown(diagnostics, `locales.${key}.${property}`);
+		if (locale.lang !== void 0 && typeof locale.lang !== "string") invalid(diagnostics, `locales.${key}.lang must be a string.`);
+		if (locale.dir !== void 0 && locale.dir !== "ltr" && locale.dir !== "rtl") invalid(diagnostics, `locales.${key}.dir must be "ltr" or "rtl".`);
+	}
+	if (config.defaultLocale !== void 0 && typeof config.defaultLocale !== "string") invalid(diagnostics, "defaultLocale must be a string.");
+	else if (config.defaultLocale !== void 0 && (config.locales === void 0 || !(config.defaultLocale in config.locales))) invalid(diagnostics, `defaultLocale must match a key in locales; received "${config.defaultLocale}".`);
+	if (config.content?.allowOutsideRoot !== void 0 && typeof config.content.allowOutsideRoot !== "boolean") invalid(diagnostics, "content.allowOutsideRoot must be a boolean.");
+	if (config.content?.localizeRepositoryLinks !== void 0 && typeof config.content.localizeRepositoryLinks !== "boolean") invalid(diagnostics, "content.localizeRepositoryLinks must be a boolean.");
+	const configuredSources = config.content?.sources;
+	if (configuredSources !== void 0 && !Array.isArray(configuredSources)) invalid(diagnostics, "content.sources must be an array.");
+	const sources = Array.isArray(configuredSources) ? configuredSources : [];
+	for (const [index, source] of sources.entries()) {
+		if (!isRecord(source)) {
+			invalid(diagnostics, `content.sources[${index}] must be an object.`);
+			continue;
+		}
+		const sourceRecord = source;
+		const variants = [
+			"file",
+			"glob",
+			"package",
+			"openapi"
+		].filter((key) => key in source);
+		if (variants.length !== 1) {
+			diagnostics.push({
+				code: "DOCS_CONFIG_INVALID",
+				severity: "error",
+				message: `content.sources[${index}] must select exactly one of file, glob, package, or openapi.`
+			});
+			continue;
+		}
+		const variant = variants[0];
+		const allowed = {
+			file: /* @__PURE__ */ new Set([
+				"id",
+				"root",
+				"routeBase",
+				"file",
+				"route",
+				"title",
+				"description",
+				"navigation"
+			]),
+			glob: /* @__PURE__ */ new Set([
+				"id",
+				"root",
+				"glob",
+				"base",
+				"routeBase",
+				"exclude",
+				"navigation"
+			]),
+			package: /* @__PURE__ */ new Set([
+				"id",
+				"package",
+				"registry",
+				"include",
+				"exclude",
+				"index",
+				"routeBase",
+				"trust"
+			]),
+			openapi: /* @__PURE__ */ new Set([
+				"id",
+				"root",
+				"routeBase",
+				"openapi"
+			])
+		}[variant];
+		for (const key of Object.keys(source)) if (!allowed.has(key)) unknown(diagnostics, `content.sources[${index}].${key}`);
+		for (const field of [
+			"id",
+			"root",
+			"route",
+			"routeBase",
+			"base",
+			"index",
+			"title",
+			"description",
+			"registry"
+		]) if (sourceRecord[field] !== void 0 && typeof sourceRecord[field] !== "string") invalid(diagnostics, `content.sources[${index}].${field} must be a string.`);
+		if (typeof sourceRecord.id === "string" && !/^[a-zA-Z0-9_-]+$/.test(sourceRecord.id)) invalid(diagnostics, `content.sources[${index}].id must contain only letters, numbers, underscores, and hyphens.`);
+		if (sourceRecord.trust !== void 0 && !["markdown", "mdx"].includes(String(sourceRecord.trust))) invalid(diagnostics, `content.sources[${index}].trust must be "markdown" or "mdx".`);
+		if (typeof sourceRecord.registry === "string" && !isHttpUrl(sourceRecord.registry)) invalid(diagnostics, `content.sources[${index}].registry must be an absolute HTTP(S) URL.`);
+		const selector = sourceRecord[variant];
+		if (variant === "glob" ? typeof selector !== "string" && (!Array.isArray(selector) || selector.some((value) => typeof value !== "string")) : typeof selector !== "string" || selector.trim() === "") invalid(diagnostics, `content.sources[${index}].${variant} must be ${variant === "glob" ? "a string or string array" : "a non-empty string"}.`);
+		for (const list of ["include", "exclude"]) {
+			const value = sourceRecord[list];
+			if (value !== void 0 && (!Array.isArray(value) || value.some((entry) => typeof entry !== "string"))) invalid(diagnostics, `content.sources[${index}].${list} must be a string array.`);
+		}
+	}
+	if (config.markdown?.stripLeadingBadges !== void 0 && typeof config.markdown.stripLeadingBadges !== "boolean") invalid(diagnostics, "markdown.stripLeadingBadges must be a boolean.");
+	if (config.markdown?.rawHtml !== void 0 && ![
+		"allow",
+		"sanitize",
+		"strip",
+		"reject"
+	].includes(config.markdown.rawHtml)) invalid(diagnostics, "markdown.rawHtml must be \"allow\", \"sanitize\", \"strip\", or \"reject\".");
+	if (config.search?.enabled !== void 0 && typeof config.search.enabled !== "boolean") invalid(diagnostics, "search.enabled must be a boolean.");
+	for (const key of ["strict", "ci"]) {
+		const value = config.build?.[key];
+		if (value !== void 0 && typeof value !== "boolean") invalid(diagnostics, `build.${key} must be a boolean.`);
+	}
+	for (const key of [
+		"maxArtifactBytes",
+		"maxUnpackedBytes",
+		"maxFiles",
+		"maxPathDepth",
+		"maxAssetBytes"
+	]) {
+		const value = config.build?.[key];
+		if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) invalid(diagnostics, `build.${key} must be a positive integer.`);
+	}
+	const brand = config.theme?.brand;
+	if (typeof brand === "object" && brand !== null && "contrast" in brand && !brand.unsafeContrast) {
+		const target = brand.contrast?.apca;
+		const normal = Array.isArray(target) ? target[0] : target;
+		if (typeof normal === "number" && normal < 45) diagnostics.push({
+			code: "DOCS_CONFIG_INVALID",
+			severity: "error",
+			message: "theme.brand.contrast.apca cannot be below 45 without unsafeContrast.",
+			hint: "Remove the override, use 45 or higher, or explicitly set unsafeContrast: true."
+		});
+	}
+	if (config.content?.frontmatter !== void 0 && !["preserve", "reject"].includes(config.content.frontmatter)) invalid(diagnostics, "content.frontmatter must be \"preserve\" or \"reject\".");
+	for (const field of [
+		"styles",
+		"customStyles",
+		"palette",
+		"glaze",
+		"units",
+		"recipes",
+		"fonts",
+		"fontLoading",
+		"tokens",
+		"states",
+		"presets",
+		"glaze",
+		"units",
+		"recipes"
+	]) if (config.theme?.[field] !== void 0 && !isRecord(config.theme[field])) invalid(diagnostics, `theme.${field} must be an object.`);
+	for (const [name, value] of Object.entries(config.theme?.units ?? {})) if (!/^[a-z][a-z0-9]*$/.test(name) || typeof value !== "string" || !value.trim()) invalid(diagnostics, `theme.units.${name} must be a named non-empty CSS length expression.`);
+	for (const [name, recipe] of Object.entries(config.theme?.recipes ?? {})) if (!/^[a-z][a-z0-9-]*$/.test(name) || name === "none" || !isRecord(recipe)) invalid(diagnostics, `theme.recipes.${name} must be a named flat Tasty style object; none is reserved.`);
+	else for (const key of Object.keys(recipe)) if (key === "recipe" || /^[A-Z]/.test(key) || /^[&.]/.test(key)) invalid(diagnostics, `theme.recipes.${name}.${key}: recipes are flat and cannot reference other recipes.`);
+	if (isRecord(config.theme?.glaze)) {
+		const settings = config.theme.glaze;
+		for (const key of Object.keys(settings)) if (![
+			"lightTone",
+			"darkTone",
+			"darkDesaturation",
+			"autoFlip",
+			"pastel",
+			"inferRole",
+			"shadowTuning"
+		].includes(key)) unknown(diagnostics, `theme.glaze.${key}`);
+		for (const key of [
+			"autoFlip",
+			"pastel",
+			"inferRole"
+		]) if (settings[key] !== void 0 && typeof settings[key] !== "boolean") invalid(diagnostics, `theme.glaze.${key} must be boolean.`);
+		if (settings.darkDesaturation !== void 0 && (typeof settings.darkDesaturation !== "number" || !Number.isFinite(settings.darkDesaturation) || settings.darkDesaturation < 0 || settings.darkDesaturation > 1)) invalid(diagnostics, "theme.glaze.darkDesaturation must be between 0 and 1.");
+		for (const key of ["lightTone", "darkTone"]) {
+			const window = settings[key];
+			if (window === void 0 || window === false) continue;
+			const lo = Array.isArray(window) ? window[0] : window?.lo;
+			const hi = Array.isArray(window) ? window[1] : window?.hi;
+			if (typeof lo !== "number" || typeof hi !== "number" || !Number.isFinite(lo) || !Number.isFinite(hi) || lo < 0 || hi > 100 || lo >= hi || (Array.isArray(window) ? window.length !== 2 : !isRecord(window) || Object.keys(window).some((key) => ![
+				"lo",
+				"hi",
+				"eps"
+			].includes(key)) || typeof window.eps !== "number" || !Number.isFinite(window.eps) || window.eps <= 0)) invalid(diagnostics, `theme.glaze.${key} must be false, [lo, hi], or {lo, hi, eps} with an ascending 0–100 range.`);
+		}
+		const tuning = settings.shadowTuning;
+		if (tuning !== void 0) {
+			if (!isRecord(tuning)) invalid(diagnostics, "theme.glaze.shadowTuning must be an object.");
+			else for (const [key, value] of Object.entries(tuning)) {
+				if (![
+					"saturationFactor",
+					"maxSaturation",
+					"lightnessFactor",
+					"lightnessBounds",
+					"minGapTarget",
+					"alphaMax",
+					"bgHueBlend"
+				].includes(key)) unknown(diagnostics, `theme.glaze.shadowTuning.${key}`);
+				if ((Array.isArray(value) ? value : [value]).some((item) => typeof item !== "number" || !Number.isFinite(item) || item < 0 || item > 1) || key === "lightnessBounds" && (!Array.isArray(value) || value.length !== 2 || value[0] > value[1])) invalid(diagnostics, `theme.glaze.shadowTuning.${key} must use values from 0 to 1.`);
+			}
+		}
+	}
+	if (isRecord(config.theme?.fontLoading)) {
+		const choices = {
+			google: ["self-hosted", "remote"],
+			cache: [
+				"reuse",
+				"refresh",
+				"offline"
+			],
+			display: [
+				"auto",
+				"block",
+				"swap",
+				"fallback",
+				"optional"
+			]
+		};
+		for (const [key, value] of Object.entries(config.theme.fontLoading)) {
+			const allowed = choices[key];
+			if (!allowed) unknown(diagnostics, `theme.fontLoading.${key}`);
+			else if (value !== void 0 && (typeof value !== "string" || !allowed.includes(value))) invalid(diagnostics, `theme.fontLoading.${key} must be ${allowed.join(" or ")}.`);
+		}
+	}
+	if (isRecord(config.theme?.fonts)) for (const [role, font] of Object.entries(config.theme.fonts)) {
+		const path = `theme.fonts.${role}`;
+		if (![
+			"body",
+			"heading",
+			"code"
+		].includes(role)) {
+			unknown(diagnostics, path);
+			continue;
+		}
+		if (font === void 0) continue;
+		if (typeof font === "string") {
+			if (!validFontFamily(font)) invalid(diagnostics, `${path} must name a Google Fonts family.`);
+			continue;
+		}
+		if (!isRecord(font)) {
+			invalid(diagnostics, `${path} must be a Google Fonts name or font definition.`);
+			continue;
+		}
+		if ("google" in font) {
+			for (const key of Object.keys(font)) if (![
+				"google",
+				"weights",
+				"styles"
+			].includes(key)) unknown(diagnostics, `${path}.${key}`);
+			if (!validFontFamily(font.google)) invalid(diagnostics, `${path}.google must name a Google Fonts family.`);
+			if (font.weights !== void 0 && (!Array.isArray(font.weights) || font.weights.length === 0 || font.weights.some((weight) => !validFontWeight(weight)))) invalid(diagnostics, `${path}.weights must be a non-empty array of weights from 1 to 1000 or ascending ranges such as "100 900".`);
+			if (font.styles !== void 0 && (!Array.isArray(font.styles) || font.styles.length === 0 || font.styles.some((style) => !["normal", "italic"].includes(style)))) invalid(diagnostics, `${path}.styles must contain normal and/or italic.`);
+		} else {
+			for (const key of Object.keys(font)) if (!["family", "files"].includes(key)) unknown(diagnostics, `${path}.${key}`);
+			if (!validFontFamily(font.family)) invalid(diagnostics, `${path}.family must be a font family name.`);
+			if (!Array.isArray(font.files) || font.files.length === 0) {
+				invalid(diagnostics, `${path}.files must contain at least one font file.`);
+				continue;
+			}
+			font.files.forEach((file, index) => {
+				const filePath = `${path}.files[${index}]`;
+				if (!isRecord(file)) {
+					invalid(diagnostics, `${filePath} must be an object.`);
+					return;
+				}
+				for (const key of Object.keys(file)) if (![
+					"src",
+					"weight",
+					"style"
+				].includes(key)) unknown(diagnostics, `${filePath}.${key}`);
+				if (typeof file.src !== "string" || !/^\/(?!\/)[^\s"'()\\?#]+\.(?:woff2?|ttf|otf)$/.test(file.src) || file.src.split("/").some((segment) => segment === "." || segment === "..")) invalid(diagnostics, `${filePath}.src must be a root-relative .woff2, .woff, .ttf, or .otf public path.`);
+				if (file.weight !== void 0 && !(typeof file.weight === "number" && Number.isInteger(file.weight) && file.weight >= 1 && file.weight <= 1e3) && !(typeof file.weight === "string" && /^(?:[1-9]\d{0,2}|1000) (?:[1-9]\d{0,2}|1000)$/.test(file.weight) && Number(file.weight.split(" ")[0]) < Number(file.weight.split(" ")[1]))) invalid(diagnostics, `${filePath}.weight must be a weight from 1 to 1000 or an ascending range.`);
+				if (file.style !== void 0 && !["normal", "italic"].includes(file.style)) invalid(diagnostics, `${filePath}.style must be normal or italic.`);
+			});
+		}
+	}
+	for (const [name, entry] of Object.entries(config.theme?.styles ?? {})) {
+		if (!COOKBOOK_COMPONENT_NAMES.includes(name)) {
+			unknown(diagnostics, `theme.styles.${name}; register custom components under theme.customStyles`);
+			continue;
+		}
+		if (!isRecord(entry)) invalid(diagnostics, `theme.styles.${name} must be a Tasty style object.`);
+		else {
+			if ("mode" in entry) invalid(diagnostics, `theme.styles.${name} must contain only Tasty properties, without a mode wrapper.`);
+			const elements = COOKBOOK_COMPONENT_SUB_ELEMENTS[name];
+			for (const key of Object.keys(entry)) if (/^[A-Z]/.test(key) && !elements.includes(key)) unknown(diagnostics, `theme.styles.${name}.${key}`);
+		}
+	}
+	for (const [name, entry] of Object.entries(config.theme?.customStyles ?? {})) {
+		if (COOKBOOK_COMPONENT_NAMES.includes(name)) invalid(diagnostics, `Use theme.styles.${name} for a built-in component.`);
+		if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(name) || !isRecord(entry) || "mode" in entry) invalid(diagnostics, `theme.customStyles.${name} must be a named partial Tasty style object.`);
+	}
+	for (const [name, value] of Object.entries(config.theme?.palette ?? {})) if (value !== void 0) validatePaletteColor(name, value, diagnostics);
+	if ((config.theme?.palette || config.theme?.glaze) && !diagnostics.some((item) => item.severity === "error")) try {
+		resolveColorTheme(config.theme);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const name = /color "([^"]+)"/.exec(message)?.[1];
+		invalid(diagnostics, `theme.palette${name ? `.${name}` : ""}: ${message}`);
+	}
+	if (brand !== void 0) try {
+		if (isBrandDeclaration(brand)) glaze.color({
+			hue: brand.hue,
+			saturation: brand.saturation,
+			tone: brand.tone
+		}).resolve();
+		else glaze.color({ from: typeof brand === "object" && brand !== null && "from" in brand ? brand.from : brand }).resolve();
+	} catch (error) {
+		invalid(diagnostics, `theme.brand: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const contrast = config.theme?.contrastLevel;
+	if (contrast !== void 0 && contrast !== "auto" && (typeof contrast !== "number" || !Number.isFinite(contrast) || contrast < 0 || contrast > 100)) invalid(diagnostics, "theme.contrastLevel must be \"auto\" or a number from 0 to 100.");
+	const componentOverrides = config.components?.overrides;
+	if (componentOverrides !== void 0 && !isRecord(componentOverrides)) invalid(diagnostics, "components.overrides must be an object.");
+	else for (const [name, override] of Object.entries(componentOverrides ?? {})) {
+		if (typeof override === "string") continue;
+		if (name === "Footer" && override === false) continue;
+		invalid(diagnostics, `components.overrides.${name} must be an Astro component path${name === "Footer" ? " or false" : ""}.`);
+	}
+	return diagnostics;
+}
+function validatePaletteColor(name, value, diagnostics) {
+	try {
+		if (!isPaletteDeclaration(value)) {
+			glaze.color({ from: value }).resolve();
+			return;
+		}
+		const keys = "type" in value ? new Set(value.type === "mix" ? [
+			"type",
+			"base",
+			"target",
+			"value",
+			"blend",
+			"space",
+			"contrast",
+			"pastel",
+			"role",
+			"inherit"
+		] : value.type === "shadow" ? [
+			"type",
+			"bg",
+			"fg",
+			"intensity",
+			"tuning",
+			"pastel",
+			"inherit"
+		] : []) : COLOR_DECLARATION_KEYS;
+		for (const key of Object.keys(value)) if (!keys.has(key)) unknown(diagnostics, `theme.palette.${name}.${key}`);
+	} catch (error) {
+		invalid(diagnostics, `theme.palette.${name}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function isPaletteDeclaration(value) {
+	return typeof value === "object" && value !== null && !("h" in value || "r" in value || "c" in value);
+}
+function isBrandDeclaration(value) {
+	return isRecord(value) && "hue" in value && "saturation" in value && "tone" in value;
+}
+function unknown(diagnostics, path) {
+	diagnostics.push({
+		code: "DOCS_CONFIG_UNKNOWN_KEY",
+		severity: "error",
+		message: `Unknown configuration key "${path}".`
+	});
+}
+function invalid(diagnostics, message) {
+	diagnostics.push({
+		code: "DOCS_CONFIG_INVALID",
+		severity: "error",
+		message
+	});
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validFontFamily(value) {
+	return typeof value === "string" && value.length <= 100 && /^[\p{L}\p{N} ._-]+$/u.test(value) && value.trim() === value && value.length > 0;
+}
+function isHttpUrl(value) {
+	try {
+		return ["http:", "https:"].includes(new URL(value).protocol);
+	} catch {
+		return false;
+	}
+}
+function validateNavigationItems(items, path, diagnostics) {
+	if (!Array.isArray(items)) {
+		invalid(diagnostics, `${path} must be an array.`);
+		return;
+	}
+	for (const [index, item] of items.entries()) {
+		const itemPath = `${path}[${index}]`;
+		if (typeof item === "string") continue;
+		if (!isRecord(item) || typeof item.label !== "string") {
+			invalid(diagnostics, `${itemPath} must be a route or a labeled navigation item.`);
+			continue;
+		}
+		if (("items" in item || "autogenerate" in item) && item.link !== void 0 && (typeof item.link !== "string" || !/^\/(?!\/)[^?#\\\s]*$/.test(item.link) || item.link.includes("//") || item.link.split("/").some((segment) => segment === "." || segment === ".."))) invalid(diagnostics, `${itemPath}.link must be a root-relative page route without a query or fragment.`);
+		if ("items" in item) validateNavigationItems(item.items, `${itemPath}.items`, diagnostics);
+		else if ("autogenerate" in item) {
+			if (!isRecord(item.autogenerate) || typeof item.autogenerate.directory !== "string") invalid(diagnostics, `${itemPath}.autogenerate.directory must be a directory path.`);
+		} else if (typeof item.link !== "string") invalid(diagnostics, `${itemPath}.link must be a URL or route.`);
+	}
+}
+function normalizeDocsConfig(config = {}) {
+	const diagnostics = validateConfig(config);
+	if (diagnostics.length > 0) throw new DocsConfigError(diagnostics);
+	const navigation = Array.isArray(config.navigation) ? { items: config.navigation } : config.navigation ?? {};
+	return {
+		...config.tableOfContents !== void 0 ? { tableOfContents: config.tableOfContents } : {},
+		redirects: { ...config.redirects },
+		site: { ...config.site },
+		head: [...config.head ?? []],
+		...config.editLink ? { editLink: { ...config.editLink } } : {},
+		lastUpdated: config.lastUpdated ?? false,
+		...config.translations ? { translations: config.translations } : {},
+		...config.locales ? { locales: { ...config.locales } } : {},
+		...config.defaultLocale ? { defaultLocale: config.defaultLocale } : {},
+		content: {
+			allowOutsideRoot: false,
+			localizeRepositoryLinks: false,
+			...config.content
+		},
+		navigation,
+		theme: {
+			...config.theme,
+			brand: config.theme?.brand ?? DEFAULT_BRAND
+		},
+		markdown: {
+			stripLeadingBadges: true,
+			rawHtml: "sanitize",
+			...config.markdown
+		},
+		search: {
+			enabled: true,
+			...config.search
+		},
+		components: { ...config.components },
+		build: {
+			strict: true,
+			ci: process.env.CI === "true",
+			base: "/",
+			cacheDir: "",
+			maxArtifactBytes: 26214400,
+			maxUnpackedBytes: 104857600,
+			maxFiles: 1e4,
+			maxPathDepth: 24,
+			maxAssetBytes: 20971520,
+			...config.build
+		}
+	};
+}
+function defineDocsConfig(config) {
+	const diagnostics = validateConfig(config);
+	if (diagnostics.length > 0) throw new DocsConfigError(diagnostics);
+	return config;
+}
+/** Compose presets. Color roles and fonts replace, other objects merge, and styles use Tasty semantics. */
+function mergeDocsConfig(...configs) {
+	const merge = (base, next) => {
+		const result = { ...base };
+		for (const [key, value] of Object.entries(next)) {
+			if (value === void 0) continue;
+			result[key] = isRecord(value) ? merge(isRecord(result[key]) ? result[key] : {}, value) : Array.isArray(value) ? [...value] : value;
+		}
+		return result;
+	};
+	return defineDocsConfig(configs.reduce((base, next) => {
+		const { palette: _palette, ...themeWithoutPalette } = next.theme ?? {};
+		const diagnostics = validateConfig({
+			...next,
+			...next.theme ? { theme: themeWithoutPalette } : {}
+		});
+		if (diagnostics.length) throw new DocsConfigError(diagnostics);
+		const result = merge(base, next);
+		if (next.site?.logo !== void 0) result.site.logo = next.site.logo;
+		if (next.site?.seo?.image !== void 0) result.site.seo.image = next.site.seo.image;
+		if (next.theme?.brand !== void 0) result.theme.brand = next.theme.brand;
+		if (next.theme?.palette) result.theme.palette = {
+			...base.theme?.palette,
+			...Object.fromEntries(Object.entries(next.theme.palette).filter(([, color]) => color !== void 0))
+		};
+		if (next.theme?.fonts) result.theme.fonts = {
+			...base.theme?.fonts,
+			...Object.fromEntries(Object.entries(next.theme.fonts).filter(([, font]) => font !== void 0))
+		};
+		for (const field of [
+			"styles",
+			"customStyles",
+			"recipes"
+		]) {
+			if (!next.theme?.[field]) continue;
+			const styles = { ...base.theme?.[field] };
+			for (const [name, configured] of Object.entries(next.theme[field])) styles[name] = mergeStyles(styles[name] ?? {}, configured);
+			if (field === "recipes") result.theme.recipes = styles;
+			else result.theme[field] = styles;
+		}
+		return result;
+	}, {}));
+}
+function validFontWeight(weight) {
+	return typeof weight === "number" && Number.isInteger(weight) && weight >= 1 && weight <= 1e3 || typeof weight === "string" && /^(?:[1-9]\d{0,2}|1000) (?:[1-9]\d{0,2}|1000)$/.test(weight) && Number(weight.split(" ")[0]) < Number(weight.split(" ")[1]);
+}
+//#endregion
+export { validateConfig as a, COOKBOOK_PALETTE_NAMES as c, routeUrl as d, routeVersion as f, normalizeDocsConfig as i, resolveColorTheme as l, validateTableOfContents as m, defineDocsConfig as n, COOKBOOK_COMPONENT_NAMES as o, validateSeo as p, mergeDocsConfig as r, COOKBOOK_COMPONENT_SUB_ELEMENTS as s, DocsConfigError as t, pagePublishing as u };
+
+//# sourceMappingURL=config-CD77r6rT.js.map