riverbankcms 0.11.0 → 0.13.0

package/dist/{sdk-event-upsert-CRQseim3.mjs → sdk-event-upsert-D48eLVOi.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { A as footerNavigationLayouts, F as isPresent, J as parseUtcIsoDateTimeString, N as isCanonicalRichTextDoc, Q as parseBookingTimeZone, Ut as err, Wt as ok, b as stableJsonStringify, dt as assertNever, j as parseFooterCompositionV1, l as EVENT_PRESET_VALUES, n as NAVIGATION_LOCATIONS, s as resolveSiteVerticalBookingConfig, u as ORDINARY_EVENT_PRESET_VALUES } from "./src-CiZrHLCj.mjs";
+import { A as footerNavigationLayouts, F as isPresent, J as parseUtcIsoDateTimeString, N as isCanonicalRichTextDoc, Q as parseBookingTimeZone, Ut as err, Wt as ok, b as stableJsonStringify, dt as assertNever, j as parseFooterCompositionV1, l as EVENT_PRESET_VALUES, n as NAVIGATION_LOCATIONS, s as resolveSiteVerticalBookingConfig, u as ORDINARY_EVENT_PRESET_VALUES } from "./src-CxEAuQpf.mjs";
 import "node:module";
 import { z } from "zod";
 
@@ -2096,21 +2096,13 @@ function parseThemeColorToken(value) {
 }
 const themeColorTokenSchema = z.string().min(1).refine((value) => Boolean(isThemeColorToken(value)), "Expected a known Theme V2 color token");
 
-//#endregion
-//#region ../theme-core/src/surfaces/foregroundRoles.ts
-const SURFACE_FOREGROUND_ROLES = [
-	"text",
-	"heading",
-	"link",
-	"supporting"
-];
-
 //#endregion
 //#region ../theme-core/src/surfaces/foregroundContract.ts
 const SURFACE_FOREGROUND_CSS_VARS = {
 	text: "--rb-surface-text-color",
 	heading: "--rb-surface-heading-color",
 	link: "--rb-surface-link-color",
+	linkHover: "--rb-surface-link-hover-color",
 	supporting: "--rb-surface-supporting-color"
 };
 const DEFAULT_SURFACE_TEXT_COLOR = "rgb(var(--tb-text, 17 24 39))";
@@ -2120,6 +2112,7 @@ const DEFAULT_ROLE_FALLBACKS = {
 	text: DEFAULT_SURFACE_TEXT_COLOR,
 	heading: DEFAULT_SURFACE_TEXT_COLOR,
 	link: DEFAULT_SURFACE_LINK_COLOR,
+	linkHover: DEFAULT_SURFACE_LINK_COLOR,
 	supporting: DEFAULT_SURFACE_SUPPORTING_COLOR
 };
 function requireSurfaceColorValue(role, value) {
@@ -2131,10 +2124,12 @@ function requireSurfaceColorValue(role, value) {
 }
 function completeSurfaceForegrounds(input) {
 	const text = requireSurfaceColorValue("text", input.text);
+	const link = input.link === undefined ? text : requireSurfaceColorValue("link", input.link);
 	return {
 		text,
 		heading: input.heading === undefined ? text : requireSurfaceColorValue("heading", input.heading),
-		link: input.link === undefined ? text : requireSurfaceColorValue("link", input.link),
+		link,
+		linkHover: input.linkHover === undefined ? link : requireSurfaceColorValue("linkHover", input.linkHover),
 		supporting: input.supporting === undefined ? text : requireSurfaceColorValue("supporting", input.supporting)
 	};
 }
@@ -2144,6 +2139,9 @@ function surfaceForegroundValue(role, outsideProviderFallback = DEFAULT_ROLE_FAL
 	if (role === "text") {
 		return `var(${roleVariable}, ${fallback})`;
 	}
+	if (role === "linkHover") {
+		return `var(${roleVariable}, ${surfaceForegroundValue("link", fallback)})`;
+	}
 	return `var(${roleVariable}, var(${SURFACE_FOREGROUND_CSS_VARS.text}, ${fallback}))`;
 }
 function surfaceForegroundValueWithOpacity(role, opacityPercent) {
@@ -2159,116 +2157,27 @@ function surfaceForegroundStyle(input) {
 		[SURFACE_FOREGROUND_CSS_VARS.text]: foregrounds.text,
 		[SURFACE_FOREGROUND_CSS_VARS.heading]: foregrounds.heading,
 		[SURFACE_FOREGROUND_CSS_VARS.link]: foregrounds.link,
-		[SURFACE_FOREGROUND_CSS_VARS.supporting]: foregrounds.supporting
+		[SURFACE_FOREGROUND_CSS_VARS.linkHover]: foregrounds.linkHover,
+		[SURFACE_FOREGROUND_CSS_VARS.supporting]: foregrounds.supporting,
+		"--rb-surface-link-hover-decoration": hoverDecoration(input)
 	};
 }
 function surfaceForegroundDeclarations(input) {
-	const foregrounds = completeSurfaceForegrounds(input);
-	return [`color: ${foregrounds.text}`, ...SURFACE_FOREGROUND_ROLES.map((role) => `${SURFACE_FOREGROUND_CSS_VARS[role]}: ${foregrounds[role]}`)];
-}
-
-//#endregion
-//#region ../theme-core/src/surfaces/foregroundInteraction.ts
-/**
-* How far a hover state softens away from its resting foreground, as a
-* percentage of full opacity.
-*
-* Softening — rather than brightening — is forced by the token vocabulary
-* rather than chosen for taste. A resolved foreground is frequently an
-* `on*` token, which `expandPalette` emits as pure `#FFFFFF` or `#000000`
-* with no shade ramp: over a primary-painted section the resolved text role
-* is `onPrimary`, and white has no headroom left to move further from its
-* background. Moving *toward* the mid-range always has headroom, whatever
-* the resting colour, and it keeps the hue exactly.
-*
-* 85% is the measured floor, not a round number. Softening costs contrast, and
-* the binding case is a scrolled overlay header: `contrast-glass` paints 60%
-* black or white, which composites the backdrop into a known band whatever the
-* page content underneath happens to be. The lightest backdrop a dark glass can
-* present is 60% black over white, `#666666`; a white foreground softened to
-* 85% reads 4.69:1 there, against 4.07:1 at 75%, which fails. Nav links are
-* 18px regular (`textSize: 'lg'`), so the bar is WCAG AA's 4.5:1 rather than
-* the large-text 3:1.
-*
-* The mirror case — a light glass over dark content, `#999999` — cannot be met
-* by any softening, because the *resting* colour is already only about 4.6:1
-* there. That is a property of the glass rather than of this derivation, and
-* it wants fixing where the glass tone is chosen.
-*/
-const FOREGROUND_HOVER_OPACITY_PERCENT = 85;
-/**
-* Derive the hover foreground that belongs with a resolved resting foreground.
-*
-* A resting foreground is chosen to be legible against a known surface. A hover
-* state derived from it stays within a bounded distance of that colour, so it
-* inherits most of the resting colour's contrast margin instead of asserting
-* an unrelated brand colour that no one checked against the surface.
-*
-* That bounded-distance property is what lets this be used on a transparent
-* overlay header, where the backdrop is only partly knowable: the scrolled
-* state composites a 60% glass tint over arbitrary page content, so no
-* compile-time contrast proof is available there. Staying near a colour that
-* is already trusted in both states is a weaker claim than a contrast proof,
-* and it is one this function can actually keep.
-*
-* Returns `null` when the resting token is not a plain palette token — an
-* already-faded or raw value has no well-defined softening, and the caller
-* should leave hover alone rather than guess.
-*/
-function deriveForegroundHoverToken(restingToken) {
-	const parts = parseColorTokenParts(restingToken);
-	if (parts.kind !== "token") return null;
-	if (parts.opacityPercent !== null) return null;
-	return parseThemeColorToken(`${parts.token}/${FOREGROUND_HOVER_OPACITY_PERCENT}`);
-}
-/**
-* The opacity `contrast-glass` paints at. Mirrors the value in
-* `generateHeaderScrollTreatmentStyles`; the two must agree, because the whole
-* point of the bound below is that it describes what that treatment can produce.
-*/
-const CONTRAST_GLASS_ALPHA = .6;
-/**
-* The extreme backdrop a glass tone can present, whatever page content happens
-* to be underneath it.
-*
-* A 60% tint clamps the composite into a known band, which is what makes a
-* conservative check possible at compile time even though the content passing
-* under a sticky header is not knowable. For a dark glass the composite is
-* lightest over white; for a light glass it is darkest over black. Those are
-* the two ends that a foreground has to survive.
-*/
-function worstCaseGlassBackdrop(tone) {
-	const [over, tint] = tone === "dark" ? ["#ffffff", "#000000"] : ["#000000", "#ffffff"];
-	return compositeHex$1(tint, over, CONTRAST_GLASS_ALPHA);
+	return Object.entries(surfaceForegroundStyle(input)).map(([property, value]) => `${property}: ${value};`);
 }
-/** Flatten `foreground` at `alpha` over `background` into an opaque hex. */
-function compositeHex$1(foreground, background, alpha) {
-	const f = hexToRgb(foreground);
-	const b = hexToRgb(background);
-	return rgbToHex(Math.round(mix$2(b.r, f.r, alpha)), Math.round(mix$2(b.g, f.g, alpha)), Math.round(mix$2(b.b, f.b, alpha)));
+function surfaceForegroundInputFromResolved(foreground, color) {
+	const { roles } = foreground;
+	return {
+		text: color(roles.text),
+		heading: color(roles.heading),
+		link: color(roles.link),
+		linkHover: color(roles.linkHover),
+		supporting: color(roles.supporting),
+		hoverDecoration: foreground.hoverDecoration
+	};
 }
-/**
-* Decide whether the resting foreground can safely be softened for hover.
-*
-* `glassTone` is the scroll treatment's compiled tone, or `null` when the style
-* has no glass. Without one there is no bound on what the header can end up
-* over, so this declines to soften rather than guess.
-*
-* The light-glass end cannot be satisfied by any softening: against `#999999`
-* a dark resting foreground is already close to the 4.5:1 line, so every step
-* away from it fails. That is why this returns a plan rather than a colour —
-* the caller has to have a non-colour affordance to fall back on.
-*/
-function planForegroundHover(restingToken, restingHex, glassTone) {
-	const softened = deriveForegroundHoverToken(restingToken);
-	if (!softened) return { kind: "resting" };
-	if (!restingHex || !glassTone) return { kind: "resting" };
-	const backdrop = worstCaseGlassBackdrop(glassTone);
-	const softenedHex = compositeHex$1(restingHex, backdrop, FOREGROUND_HOVER_OPACITY_PERCENT / 100);
-	return contrastRatio(softenedHex, backdrop) >= ORDINARY_TEXT_MIN_CONTRAST_RATIO ? {
-		kind: "softened",
-		token: softened
-	} : { kind: "resting" };
+function hoverDecoration(input) {
+	return input.hoverDecoration ?? "underline";
 }
 
 //#endregion
@@ -2446,11 +2355,11 @@ function resolveOpaqueSurfaceHex(reference, palette, underlayReference) {
 	const parts = parseColorTokenParts(reference);
 	if (parts.kind === "token" && parts.opacityPercent !== null) {
 		const foregroundHex = normalizePaletteHex(palette[parts.token] ?? "");
-		return foregroundHex ? compositeHex(foregroundHex, underlayHex, parts.opacityPercent / 100) : null;
+		return foregroundHex ? compositeHex$1(foregroundHex, underlayHex, parts.opacityPercent / 100) : null;
 	}
 	const raw = parts.kind === "raw" ? parts.value : reference;
 	const rgba = parseRgba(raw);
-	return rgba ? compositeHex(rgbToHex(rgba.r, rgba.g, rgba.b), underlayHex, rgba.alpha) : null;
+	return rgba ? compositeHex$1(rgbToHex(rgba.r, rgba.g, rgba.b), underlayHex, rgba.alpha) : null;
 }
 /** Resolve a colour reference only when it is already fully opaque. */
 function resolveConcreteColorHex(reference, palette) {
@@ -2466,7 +2375,7 @@ function resolveConcreteColorHex(reference, palette) {
 	if (literal.toLowerCase() === "white") return "#ffffff";
 	return normalizePaletteHex(literal);
 }
-function compositeHex(foregroundHex, underlayHex, alpha) {
+function compositeHex$1(foregroundHex, underlayHex, alpha) {
 	const foreground = hexToRgb(foregroundHex);
 	const underlay = hexToRgb(underlayHex);
 	const channel = (foregroundValue, underlayValue) => Math.round(foregroundValue * alpha + underlayValue * (1 - alpha));
@@ -2500,6 +2409,134 @@ function isRgbChannel(value) {
 	return Number.isFinite(value) && value >= 0 && value <= 255;
 }
 
+//#endregion
+//#region ../theme-core/src/surfaces/foregroundInteraction.ts
+/**
+* How far a hover state softens away from its resting foreground, as a
+* percentage of full opacity.
+*
+* Softening — rather than brightening — is forced by the token vocabulary
+* rather than chosen for taste. A resolved foreground is frequently an
+* `on*` token, which `expandPalette` emits as pure `#FFFFFF` or `#000000`
+* with no shade ramp: over a primary-painted section the resolved text role
+* is `onPrimary`, and white has no headroom left to move further from its
+* background. Moving *toward* the mid-range always has headroom, whatever
+* the resting colour, and it keeps the hue exactly.
+*
+* 85% is the measured floor, not a round number. Softening costs contrast, and
+* the binding case is a scrolled overlay header: `contrast-glass` paints 60%
+* black or white, which composites the backdrop into a known band whatever the
+* page content underneath happens to be. The lightest backdrop a dark glass can
+* present is 60% black over white, `#666666`; a white foreground softened to
+* 85% reads 4.69:1 there, against 4.07:1 at 75%, which fails. Nav links are
+* 18px regular (`textSize: 'lg'`), so the bar is WCAG AA's 4.5:1 rather than
+* the large-text 3:1.
+*
+* The mirror case — a light glass over dark content, `#999999` — cannot be met
+* by any softening, because the *resting* colour is already only about 4.6:1
+* there. That is a property of the glass rather than of this derivation, and
+* it wants fixing where the glass tone is chosen.
+*/
+const FOREGROUND_HOVER_OPACITY_PERCENT = 85;
+/**
+* Derive the hover foreground that belongs with a resolved resting foreground.
+*
+* A resting foreground is chosen to be legible against a known surface. A hover
+* state derived from it stays within a bounded distance of that colour, so it
+* inherits most of the resting colour's contrast margin instead of asserting
+* an unrelated brand colour that no one checked against the surface.
+*
+* That bounded-distance property is what lets this be used on a transparent
+* overlay header, where the backdrop is only partly knowable: the scrolled
+* state composites a 60% glass tint over arbitrary page content, so no
+* compile-time contrast proof is available there. Staying near a colour that
+* is already trusted in both states is a weaker claim than a contrast proof,
+* and it is one this function can actually keep.
+*
+* Returns `null` when the resting token is not a plain palette token — an
+* already-faded or raw value has no well-defined softening, and the caller
+* should leave hover alone rather than guess.
+*/
+function deriveForegroundHoverToken(restingToken) {
+	const parts = parseColorTokenParts(restingToken);
+	if (parts.kind !== "token") return null;
+	if (parts.opacityPercent !== null) return null;
+	return parseThemeColorToken(`${parts.token}/${FOREGROUND_HOVER_OPACITY_PERCENT}`);
+}
+/**
+* The opacity `contrast-glass` paints at. Mirrors the value in
+* `generateHeaderScrollTreatmentStyles`; the two must agree, because the whole
+* point of the bound below is that it describes what that treatment can produce.
+*/
+const CONTRAST_GLASS_ALPHA = .6;
+/**
+* The extreme backdrop a glass tone can present, whatever page content happens
+* to be underneath it.
+*
+* A 60% tint clamps the composite into a known band, which is what makes a
+* conservative check possible at compile time even though the content passing
+* under a sticky header is not knowable. For a dark glass the composite is
+* lightest over white; for a light glass it is darkest over black. Those are
+* the two ends that a foreground has to survive.
+*/
+function worstCaseGlassBackdrop(tone) {
+	const [over, tint] = tone === "dark" ? ["#ffffff", "#000000"] : ["#000000", "#ffffff"];
+	return compositeHex(tint, over, CONTRAST_GLASS_ALPHA);
+}
+/** Flatten `foreground` at `alpha` over `background` into an opaque hex. */
+function compositeHex(foreground, background, alpha) {
+	const f = hexToRgb(foreground);
+	const b = hexToRgb(background);
+	return rgbToHex(Math.round(mix$2(b.r, f.r, alpha)), Math.round(mix$2(b.g, f.g, alpha)), Math.round(mix$2(b.b, f.b, alpha)));
+}
+/**
+* Prefer an authored hover that survives every measured backdrop, then a
+* checked softening of the resting colour. A null backdrop set represents a
+* trusted treatment: only an explicit authored hover may change the colour.
+* When neither option works, retain the resting colour and underline it.
+*/
+function planForegroundHover(input) {
+	const { restingToken, candidate: candidate$1, palette, backdrops } = input;
+	if (candidate$1 && candidate$1 !== restingToken) {
+		if (backdrops === null || survivesEveryBackdrop(candidate$1, palette, backdrops)) {
+			return {
+				kind: "candidate",
+				token: candidate$1,
+				decoration: "initial"
+			};
+		}
+	}
+	const softened = deriveForegroundHoverToken(restingToken);
+	if (softened && backdrops && survivesEveryBackdrop(softened, palette, backdrops)) {
+		return {
+			kind: "softened",
+			token: softened,
+			decoration: "initial"
+		};
+	}
+	return {
+		kind: "resting",
+		token: restingToken,
+		decoration: "underline"
+	};
+}
+function survivesEveryBackdrop(token, palette, backdrops) {
+	return backdrops.length > 0 && backdrops.every((backdrop) => {
+		const foreground = resolveOpaqueSurfaceHex(token, palette, backdrop);
+		return foreground !== null && contrastRatio(foreground, backdrop) >= ORDINARY_TEXT_MIN_CONTRAST_RATIO;
+	});
+}
+
+//#endregion
+//#region ../theme-core/src/surfaces/foregroundRoles.ts
+const SURFACE_FOREGROUND_ROLES = [
+	"text",
+	"heading",
+	"link",
+	"linkHover",
+	"supporting"
+];
+
 //#endregion
 //#region ../theme-core/src/surfaces/resolveSurfaceForeground.ts
 const FALLBACK_TEXT_TOKENS = [
@@ -2550,12 +2587,16 @@ function resolveSurfaceForeground(background, palette, candidates = {}, options
 }
 function foregroundCandidates(background, overrides) {
 	return {
-		text: overrides.text ?? background?.textColor ?? null,
-		heading: overrides.heading ?? background?.headingColor ?? null,
-		link: overrides.link ?? background?.linkColor ?? null,
-		supporting: overrides.supporting ?? background?.supportingColor ?? null
+		text: candidateOrBackground(overrides.text, background?.textColor),
+		heading: candidateOrBackground(overrides.heading, background?.headingColor),
+		link: candidateOrBackground(overrides.link, background?.linkColor),
+		linkHover: candidateOrBackground(overrides.linkHover),
+		supporting: candidateOrBackground(overrides.supporting, background?.supportingColor)
 	};
 }
+function candidateOrBackground(candidate$1, backgroundValue) {
+	return candidate$1 ?? backgroundValue ?? null;
+}
 function resolveDeterministicForeground(backgroundReference, candidates, palette, compositeBase) {
 	const backgroundHex = resolveOpaqueSurfaceHex(backgroundReference, palette, compositeBase);
 	if (!backgroundHex) {
@@ -2569,29 +2610,53 @@ function resolveDeterministicForeground(backgroundReference, candidates, palette
 		...FALLBACK_TEXT_TOKENS
 	], backgroundHex, palette, derivedOnToken ? [derivedOnToken] : []);
 	if (!text) return { kind: "unknown" };
-	return {
-		kind: "known",
-		roles: {
-			text,
-			heading: safeTokenOr(candidates.heading, text, backgroundHex, palette),
-			link: safeTokenOr(candidates.link, text, backgroundHex, palette),
-			supporting: safeTokenOr(candidates.supporting, text, backgroundHex, palette)
-		}
-	};
+	return knownForeground({
+		text,
+		heading: safeTokenOr(candidates.heading, text, backgroundHex, palette),
+		link: safeTokenOr(candidates.link, text, backgroundHex, palette),
+		supporting: safeTokenOr(candidates.supporting, text, backgroundHex, palette)
+	}, {
+		kind: "measured",
+		backdropHex: backgroundHex
+	}, candidates.linkHover, palette);
 }
 function resolveTrustedTreatmentForeground(candidates, palette) {
 	const text = canonicalToken(candidates.text, palette);
 	if (!text) return { kind: "unknown" };
+	return knownForeground({
+		text,
+		heading: canonicalToken(candidates.heading, palette) ?? text,
+		link: canonicalToken(candidates.link, palette) ?? text,
+		supporting: canonicalToken(candidates.supporting, palette) ?? text
+	}, { kind: "trusted-treatment" }, candidates.linkHover, palette);
+}
+function knownForeground(roles, provenance, hoverCandidate, palette) {
+	const hover = planForegroundHover({
+		restingToken: roles.link,
+		candidate: canonicalHoverToken(hoverCandidate, palette),
+		palette,
+		backdrops: provenance.kind === "measured" ? [provenance.backdropHex] : null
+	});
 	return {
 		kind: "known",
+		provenance,
 		roles: {
-			text,
-			heading: canonicalToken(candidates.heading, palette) ?? text,
-			link: canonicalToken(candidates.link, palette) ?? text,
-			supporting: canonicalToken(candidates.supporting, palette) ?? text
-		}
+			...roles,
+			linkHover: hover.token
+		},
+		hoverDecoration: hover.decoration
 	};
 }
+function canonicalHoverToken(reference, palette) {
+	const token = parseThemeColorToken(reference);
+	if (token) {
+		const parts = parseColorTokenParts(token);
+		if (parts.kind === "token" && resolveConcreteColorHex(parts.token, palette)) {
+			return token;
+		}
+	}
+	return canonicalToken(reference, palette);
+}
 function safeTokenOr(candidate$1, fallback, backgroundHex, palette) {
 	return firstSafeToken([candidate$1], backgroundHex, palette) ?? fallback;
 }
@@ -3591,6 +3656,226 @@ function resolveCardRole(theme, cardSystem, role) {
 	}
 }
 
+//#endregion
+//#region ../theme-core/src/palette/generateShades.ts
+function generateShades(hexColor, name) {
+	const shadeSteps = [
+		50,
+		100,
+		200,
+		300,
+		400,
+		500,
+		600,
+		700,
+		800,
+		900,
+		950
+	];
+	const base = featuresFromHex(hexColor);
+	const hue = base.okH;
+	const baseChroma = base.okC;
+	const toneMap = {
+		50: .975,
+		100: .945,
+		200: .89,
+		300: .82,
+		400: .74,
+		500: .66,
+		600: .58,
+		700: .49,
+		800: .4,
+		900: .28,
+		950: .16
+	};
+	const shadeDefs = shadeSteps.map((step, idx) => {
+		const t = idx / (shadeSteps.length - 1);
+		const L = toneMap[step];
+		const chromaFactor = .06 + .94 * Math.sin(Math.PI * t);
+		const C = baseChroma * chromaFactor;
+		return {
+			name: `${name}-${step}`,
+			hex: oklchToHexGamut(L, C, hue)
+		};
+	});
+	shadeDefs.push({
+		name,
+		hex: hexColor
+	});
+	return shadeDefs;
+}
+
+//#endregion
+//#region ../theme-core/src/palette/neutralScale.ts
+function generateNeutralScale({ background, steps = 11, warm = false }) {
+	const isDark = background === "#000000" || background.startsWith("#0") || background.startsWith("#1");
+	const shadeNames = [
+		50,
+		100,
+		200,
+		300,
+		400,
+		500,
+		600,
+		700,
+		800,
+		900,
+		950
+	];
+	const count = Math.min(steps, shadeNames.length);
+	const scale$1 = [];
+	for (let i = 0; i < count; i++) {
+		const shadeName = shadeNames[i] ?? shadeNames[shadeNames.length - 1] ?? 950;
+		const t = i / (count - 1);
+		const tone = isDark ? mix$1(.06, .92, t) : mix$1(.98, .1, t);
+		const hex = oklchToHexGamut(tone, .02, warm ? 85 : 250);
+		const name = `neutral-${shadeName}`;
+		scale$1.push({
+			name,
+			hex
+		});
+	}
+	return scale$1;
+}
+function mix$1(a, b, t) {
+	return a + (b - a) * Math.max(0, Math.min(1, t));
+}
+
+//#endregion
+//#region ../theme-core/src/palette/utils/textColor.ts
+/**
+* Pick the better of black/white text for a given background using actual
+* contrast ratios, not a simple luminance cutoff.
+*
+* @param background - Background color in hex or rgb/rgba format (e.g., '#FFFFFF' or 'rgb(255, 255, 255)')
+* @param minContrast - Preferred minimum contrast ratio for body-sized text
+* @returns '#000000' for light backgrounds, '#FFFFFF' for dark backgrounds
+*/
+function pickBlackOrWhiteTextColor(background, minContrast = 4.5) {
+	const { r, g, b } = parseColorToRgb(background);
+	const luminance = relativeLuminance(r, g, b);
+	const blackContrast = (luminance + .05) / .05;
+	const whiteContrast = 1.05 / (luminance + .05);
+	if (blackContrast >= minContrast && whiteContrast < minContrast) {
+		return "#000000";
+	}
+	if (whiteContrast >= minContrast && blackContrast < minContrast) {
+		return "#FFFFFF";
+	}
+	return blackContrast >= whiteContrast ? "#000000" : "#FFFFFF";
+}
+/**
+* Backwards-compatible alias for callers that want the best black/white text
+* color for a background.
+*/
+function getTextColorForBackground(background) {
+	return pickBlackOrWhiteTextColor(background);
+}
+function parseColorToRgb(input) {
+	const trimmed = input.trim();
+	if (trimmed.startsWith("#")) {
+		return hexToRgb(trimmed);
+	}
+	const rgbMatch = trimmed.match(/^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})(?:\s*,\s*(?:0|1|0?\.\d+))?\s*\)$/i);
+	if (rgbMatch?.[1] && rgbMatch[2] && rgbMatch[3]) {
+		return {
+			r: clamp255(Number(rgbMatch[1])),
+			g: clamp255(Number(rgbMatch[2])),
+			b: clamp255(Number(rgbMatch[3]))
+		};
+	}
+	throw new Error("Unsupported color format");
+}
+function clamp255(value) {
+	if (Number.isNaN(value)) return 0;
+	return Math.max(0, Math.min(255, value));
+}
+
+//#endregion
+//#region ../theme-core/src/palette/expandPalette.ts
+function colorsToMap$1(palette) {
+	const map = {};
+	for (const c of palette.colors) {
+		map[c.name] = c.hex;
+	}
+	return map;
+}
+function isBackgroundDark(hex) {
+	try {
+		return featuresFromHex(hex).Y < .5;
+	} catch {
+		return false;
+	}
+}
+const nonShadeablePaletteRoleNames = new Set([
+	"success",
+	"warning",
+	"destructive"
+]);
+/**
+* Status role aliases the persisted palette does not carry itself.
+*
+* Generators reference `--tb-error` (the site-style-owned input error border)
+* and `--tb-info` (`.alert-info`, `.status-info`, the field-note rule), but the
+* palette schema only defines `destructive` and has no `info` role at all.
+* Without these aliases those declarations name variables that are never
+* defined and browsers drop them. The SDK bridge resolves the same pair via
+* TOKEN_ALIASES, so both runtimes agree on what a status token means.
+*
+* Runs after the danger → destructive promotion above, so `destructive` is
+* already the single source of truth for the error colour.
+*/
+function statusAliasTokens(expanded) {
+	const aliases = {};
+	if (expanded.destructive) aliases.error = expanded.destructive;
+	if (expanded.accent) aliases.info = expanded.accent;
+	return aliases;
+}
+function expandPalette(palette) {
+	const base = colorsToMap$1(palette);
+	const expanded = { ...base };
+	const background = base.background || base.surface || "#ffffff";
+	const neutral$1 = generateNeutralScale({
+		background,
+		steps: 11,
+		warm: false
+	});
+	neutral$1.forEach((n) => {
+		expanded[n.name] = n.hex;
+	});
+	for (const [name, hex] of Object.entries(base)) {
+		if (nonShadeablePaletteRoleNames.has(name)) continue;
+		if (hex) {
+			const shades = generateShades(hex, name);
+			shades.forEach((shade) => {
+				expanded[shade.name] = shade.hex;
+			});
+		}
+	}
+	if (base.text) expanded.body = base.text;
+	if (base.danger && !base.destructive) {
+		expanded.destructive = base.danger;
+	}
+	Object.assign(expanded, statusAliasTokens(expanded));
+	const isDark = base.background ? isBackgroundDark(base.background) : false;
+	const isDarkMode = palette.meta?.mode === "dark" || isDark;
+	expanded.mutedText = isDarkMode ? expanded["neutral-600"] ?? "#666" : expanded["neutral-500"] ?? "#888";
+	for (const [token, hex] of Object.entries({ ...expanded })) {
+		if (!hex || !isOnColorBackgroundCandidateToken(token)) continue;
+		const onToken = onColorTokenName(token);
+		if (expanded[onToken]) continue;
+		expanded[onToken] = getTextColorForBackground(hex);
+	}
+	return expanded;
+}
+
+//#endregion
+//#region ../theme-core/src/utils/cssDeclarations.ts
+/** Render CSS declarations whether callers provide terminators or fragments. */
+function renderCssDeclarations(declarations) {
+	return declarations.map((declaration) => declaration.endsWith(";") ? declaration : `${declaration};`).join("\n  ");
+}
+
 //#endregion
 //#region ../theme-core/src/cards/generateCardCss.ts
 const PER_CORNER_RADIUS_MAP$1 = {
@@ -3608,6 +3893,7 @@ function resolveCornerRadiiCss$1(cornerRadii, fallback) {
 function generateCardCss(options) {
 	const { themeId, theme, cardSystem: providedCardSystem } = options;
 	const tokens = new TokenResolver(theme);
+	const palette = expandPalette(theme.palette);
 	const cardSystem = providedCardSystem ?? generateDefaultCardSystem(theme);
 	const source = providedCardSystem ? "site-style" : "generated-baseline";
 	const aliasGroups = resolveRoleAliasGroups(theme, providedCardSystem ?? null);
@@ -3618,11 +3904,11 @@ function generateCardCss(options) {
 		const groupKey = roleAliasGroupKey(source, variant.id);
 		emittedGroupKeys.add(groupKey);
 		const aliasClasses = aliasGroups.get(groupKey)?.classes ?? [];
-		cssChunks.push(generateVariantCSS(variant, themeId, [`card-${variant.id}`, ...aliasClasses], tokens, theme));
+		cssChunks.push(generateVariantCSS(variant, themeId, [`card-${variant.id}`, ...aliasClasses], tokens, theme, palette));
 	}
 	for (const [groupKey, group] of aliasGroups) {
 		if (emittedGroupKeys.has(groupKey)) continue;
-		cssChunks.push(generateVariantCSS(group.variant, themeId, group.classes, tokens, theme));
+		cssChunks.push(generateVariantCSS(group.variant, themeId, group.classes, tokens, theme, palette));
 	}
 	return cssChunks.filter(Boolean).join("\n\n");
 }
@@ -3685,7 +3971,7 @@ const MEDIA_CORNER_MAP = {
 * This CSS-first approach eliminates runtime transforms for styling,
 * keeping transforms only for data normalization and dynamic layout.
 */
-function generateVariantCSS(variant, themeId, cardClasses, tokens, theme) {
+function generateVariantCSS(variant, themeId, cardClasses, tokens, theme, palette) {
 	const selectorsFor = (suffix) => cardClasses.map((cardClass) => `:where([data-theme-scope="${themeId}"]) .${cardClass}.${cardClass}${suffix}`).join(",\n");
 	const containerSelectors = cardClasses.map((cardClass) => `:where([data-theme-scope="${themeId}"]) .${cardClass}.${cardClass}`);
 	const containerSelector = containerSelectors.join(",\n");
@@ -3693,21 +3979,7 @@ function generateVariantCSS(variant, themeId, cardClasses, tokens, theme) {
 	const contentSelector = selectorsFor(" .card-content");
 	const fallbackBackgroundSelector = selectorsFor(" > .rb-bg-surface");
 	const rules = [];
-	if (variant.background.type === "solid") {
-		const bgColor = tokens.getColor(variant.background.colorToken);
-		rules.push(`background: ${bgColor}`);
-	} else if (variant.background.type === "gradient") {
-		const fromColor = tokens.getColor(variant.background.fromToken);
-		const toColor = tokens.getColor(variant.background.toToken);
-		const direction = GRADIENT_DIRECTION_MAP$2[variant.background.direction] || "to right";
-		rules.push(`background: linear-gradient(${direction}, ${fromColor}, ${toColor})`);
-	} else {
-		rules.push(`background: transparent`);
-	}
-	if (variant.background.type !== "transparent") {
-		const foreground = tokens.getColor(variant.foregroundToken ?? "text");
-		rules.push(...surfaceForegroundDeclarations({ text: foreground }));
-	}
+	rules.push(...cardSurfaceRules(variant, tokens, theme, palette));
 	const resolveColor = (token) => tokens.getColor(token);
 	rules.push(...cardBorderDeclarations(variant.border ? borderDeclaration(variant.border, tokens) : null, variant.decorations, resolveColor));
 	const corners$1 = variant.corners ?? theme.corners;
@@ -3724,13 +3996,35 @@ function generateVariantCSS(variant, themeId, cardClasses, tokens, theme) {
 	const contentRules = [`padding: ${resolveContentPadding(variant)}`];
 	return [
 		`${structureSelector} {\n  display: flex;\n  flex-direction: column;\n  position: relative;\n  overflow: visible;\n}`,
-		`${containerSelector} {\n  ${rules.join(";\n  ")};\n}`,
+		`${containerSelector} {\n  ${renderCssDeclarations(rules)}\n}`,
 		...cardDecorationPseudoRules(containerSelectors, variant.decorations, resolveColor),
 		`${fallbackBackgroundSelector} {\n  background: transparent;\n}`,
 		`${mediaSelector} {\n  ${mediaRules.join(";\n  ")};\n}`,
 		`${contentSelector} {\n  ${contentRules.join(";\n  ")};\n}`
 	].join("\n\n");
 }
+function cardSurfaceRules(variant, tokens, theme, palette) {
+	if (variant.background.type === "transparent") return ["background: transparent"];
+	const background = variant.background.type === "solid" ? {
+		type: "color",
+		color: variant.background.colorToken,
+		textColor: variant.foregroundToken ?? "text"
+	} : {
+		type: "gradient",
+		textColor: variant.foregroundToken ?? "text"
+	};
+	const foreground = resolveSurfaceForeground(background, palette, { linkHover: theme.typography.proseLinkStyle?.hoverColorToken });
+	return [cardBackgroundRule(variant.background, tokens), ...surfaceForegroundDeclarations(foreground.kind === "known" ? surfaceForegroundInputFromResolved(foreground, (token) => tokens.getColor(token)) : { text: tokens.getColor(variant.foregroundToken ?? "text") })];
+}
+function cardBackgroundRule(background, tokens) {
+	if (background.type === "solid") {
+		return `background: ${tokens.getColor(background.colorToken)}`;
+	}
+	const from = tokens.getColor(background.fromToken);
+	const to = tokens.getColor(background.toToken);
+	const direction = GRADIENT_DIRECTION_MAP$2[background.direction] || "to right";
+	return `background: linear-gradient(${direction}, ${from}, ${to})`;
+}
 function borderDeclaration(border$1, tokens) {
 	const borderColor = tokens.getColor(border$1.colorToken);
 	const borderWidth = border$1.widthClass === "border-4" ? "4px" : border$1.widthClass === "border-2" ? "2px" : border$1.widthClass === "border" ? "1px" : "1px";
@@ -3848,6 +4142,9 @@ function generateCardCoreCss(scopeId, variants, settings, scope = "all") {
 * A variant's background and, when it owns one, the complete foreground
 * contract that goes with it. Opaque cards are surface providers; transparent
 * variants inherit the nearest outer surface atomically and declare nothing.
+* The SDK bridge has token references but no resolved palette or global prose
+* preference. It therefore publishes the conservative resting hover plus
+* underline through the shared contract instead of claiming measured contrast.
 */
 function cardSurfaceDeclarations(variant) {
 	if (variant.background === "solid" && variant.backgroundToken) {
@@ -3888,7 +4185,7 @@ function generateVariantCss(scopeId, variant, settings, scope = "all") {
 	const mediaRules = mediaCornerRules(variant.cornerRadii, settings.corners);
 	const contentRules = [`padding: ${SPACING_MAP[variant.spacing]}`];
 	return [
-		`${containerSelector} {\n  ${containerRules.join(";\n  ")};\n}`,
+		`${containerSelector} {\n  ${renderCssDeclarations(containerRules)}\n}`,
 		...cardDecorationPseudoRules(containerSelectors, decorations, coreColor),
 		`${fallbackBackgroundSelector} {\n  background: transparent;\n}`,
 		`${mediaSelector} {\n  ${mediaRules.join(";\n  ")};\n}`,
@@ -12789,219 +13086,6 @@ const paletteSchema = z.object({
 	};
 });
 
-//#endregion
-//#region ../theme-core/src/palette/generateShades.ts
-function generateShades(hexColor, name) {
-	const shadeSteps = [
-		50,
-		100,
-		200,
-		300,
-		400,
-		500,
-		600,
-		700,
-		800,
-		900,
-		950
-	];
-	const base = featuresFromHex(hexColor);
-	const hue = base.okH;
-	const baseChroma = base.okC;
-	const toneMap = {
-		50: .975,
-		100: .945,
-		200: .89,
-		300: .82,
-		400: .74,
-		500: .66,
-		600: .58,
-		700: .49,
-		800: .4,
-		900: .28,
-		950: .16
-	};
-	const shadeDefs = shadeSteps.map((step, idx) => {
-		const t = idx / (shadeSteps.length - 1);
-		const L = toneMap[step];
-		const chromaFactor = .06 + .94 * Math.sin(Math.PI * t);
-		const C = baseChroma * chromaFactor;
-		return {
-			name: `${name}-${step}`,
-			hex: oklchToHexGamut(L, C, hue)
-		};
-	});
-	shadeDefs.push({
-		name,
-		hex: hexColor
-	});
-	return shadeDefs;
-}
-
-//#endregion
-//#region ../theme-core/src/palette/neutralScale.ts
-function generateNeutralScale({ background, steps = 11, warm = false }) {
-	const isDark = background === "#000000" || background.startsWith("#0") || background.startsWith("#1");
-	const shadeNames = [
-		50,
-		100,
-		200,
-		300,
-		400,
-		500,
-		600,
-		700,
-		800,
-		900,
-		950
-	];
-	const count = Math.min(steps, shadeNames.length);
-	const scale$1 = [];
-	for (let i = 0; i < count; i++) {
-		const shadeName = shadeNames[i] ?? shadeNames[shadeNames.length - 1] ?? 950;
-		const t = i / (count - 1);
-		const tone = isDark ? mix$1(.06, .92, t) : mix$1(.98, .1, t);
-		const hex = oklchToHexGamut(tone, .02, warm ? 85 : 250);
-		const name = `neutral-${shadeName}`;
-		scale$1.push({
-			name,
-			hex
-		});
-	}
-	return scale$1;
-}
-function mix$1(a, b, t) {
-	return a + (b - a) * Math.max(0, Math.min(1, t));
-}
-
-//#endregion
-//#region ../theme-core/src/palette/utils/textColor.ts
-/**
-* Pick the better of black/white text for a given background using actual
-* contrast ratios, not a simple luminance cutoff.
-*
-* @param background - Background color in hex or rgb/rgba format (e.g., '#FFFFFF' or 'rgb(255, 255, 255)')
-* @param minContrast - Preferred minimum contrast ratio for body-sized text
-* @returns '#000000' for light backgrounds, '#FFFFFF' for dark backgrounds
-*/
-function pickBlackOrWhiteTextColor(background, minContrast = 4.5) {
-	const { r, g, b } = parseColorToRgb(background);
-	const luminance = relativeLuminance(r, g, b);
-	const blackContrast = (luminance + .05) / .05;
-	const whiteContrast = 1.05 / (luminance + .05);
-	if (blackContrast >= minContrast && whiteContrast < minContrast) {
-		return "#000000";
-	}
-	if (whiteContrast >= minContrast && blackContrast < minContrast) {
-		return "#FFFFFF";
-	}
-	return blackContrast >= whiteContrast ? "#000000" : "#FFFFFF";
-}
-/**
-* Backwards-compatible alias for callers that want the best black/white text
-* color for a background.
-*/
-function getTextColorForBackground(background) {
-	return pickBlackOrWhiteTextColor(background);
-}
-function parseColorToRgb(input) {
-	const trimmed = input.trim();
-	if (trimmed.startsWith("#")) {
-		return hexToRgb(trimmed);
-	}
-	const rgbMatch = trimmed.match(/^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})(?:\s*,\s*(?:0|1|0?\.\d+))?\s*\)$/i);
-	if (rgbMatch?.[1] && rgbMatch[2] && rgbMatch[3]) {
-		return {
-			r: clamp255(Number(rgbMatch[1])),
-			g: clamp255(Number(rgbMatch[2])),
-			b: clamp255(Number(rgbMatch[3]))
-		};
-	}
-	throw new Error("Unsupported color format");
-}
-function clamp255(value) {
-	if (Number.isNaN(value)) return 0;
-	return Math.max(0, Math.min(255, value));
-}
-
-//#endregion
-//#region ../theme-core/src/palette/expandPalette.ts
-function colorsToMap$1(palette) {
-	const map = {};
-	for (const c of palette.colors) {
-		map[c.name] = c.hex;
-	}
-	return map;
-}
-function isBackgroundDark(hex) {
-	try {
-		return featuresFromHex(hex).Y < .5;
-	} catch {
-		return false;
-	}
-}
-const nonShadeablePaletteRoleNames = new Set([
-	"success",
-	"warning",
-	"destructive"
-]);
-/**
-* Status role aliases the persisted palette does not carry itself.
-*
-* Generators reference `--tb-error` (the site-style-owned input error border)
-* and `--tb-info` (`.alert-info`, `.status-info`, the field-note rule), but the
-* palette schema only defines `destructive` and has no `info` role at all.
-* Without these aliases those declarations name variables that are never
-* defined and browsers drop them. The SDK bridge resolves the same pair via
-* TOKEN_ALIASES, so both runtimes agree on what a status token means.
-*
-* Runs after the danger → destructive promotion above, so `destructive` is
-* already the single source of truth for the error colour.
-*/
-function statusAliasTokens(expanded) {
-	const aliases = {};
-	if (expanded.destructive) aliases.error = expanded.destructive;
-	if (expanded.accent) aliases.info = expanded.accent;
-	return aliases;
-}
-function expandPalette(palette) {
-	const base = colorsToMap$1(palette);
-	const expanded = { ...base };
-	const background = base.background || base.surface || "#ffffff";
-	const neutral$1 = generateNeutralScale({
-		background,
-		steps: 11,
-		warm: false
-	});
-	neutral$1.forEach((n) => {
-		expanded[n.name] = n.hex;
-	});
-	for (const [name, hex] of Object.entries(base)) {
-		if (nonShadeablePaletteRoleNames.has(name)) continue;
-		if (hex) {
-			const shades = generateShades(hex, name);
-			shades.forEach((shade) => {
-				expanded[shade.name] = shade.hex;
-			});
-		}
-	}
-	if (base.text) expanded.body = base.text;
-	if (base.danger && !base.destructive) {
-		expanded.destructive = base.danger;
-	}
-	Object.assign(expanded, statusAliasTokens(expanded));
-	const isDark = base.background ? isBackgroundDark(base.background) : false;
-	const isDarkMode = palette.meta?.mode === "dark" || isDark;
-	expanded.mutedText = isDarkMode ? expanded["neutral-600"] ?? "#666" : expanded["neutral-500"] ?? "#888";
-	for (const [token, hex] of Object.entries({ ...expanded })) {
-		if (!hex || !isOnColorBackgroundCandidateToken(token)) continue;
-		const onToken = onColorTokenName(token);
-		if (expanded[onToken]) continue;
-		expanded[onToken] = getTextColorForBackground(hex);
-	}
-	return expanded;
-}
-
 //#endregion
 //#region ../theme-core/src/buttons/constants.ts
 /**
@@ -17025,6 +17109,48 @@ const effectCompositionSchema = z.object({
 	focus: z.array(effectApplicationSchema).optional()
 });
 
+//#endregion
+//#region ../theme-core/src/navigation/effectPolicy.ts
+/** Every registered effect has one meaning for surface-owned nav hover. */
+const NAV_EFFECT_POLICIES = {
+	"darken-background": "other",
+	"lighten-background": "other",
+	"fade-background": "other",
+	"opacity-reduce": "other",
+	"animated-gradient": "other",
+	"background-on-hover": "paired-hover",
+	"background-on-hover-alpha": "paired-hover",
+	"border-glow": "other",
+	"drop-shadow": "other",
+	"inner-shadow": "other",
+	"neumorphic-shadow": "other",
+	"outer-glow": "other",
+	"retro-3d-shadow": "other",
+	"scale-up": "other",
+	"scale-down": "other",
+	lift: "other",
+	"press-down": "other",
+	pop: "other",
+	"aurora-glow": "other",
+	"cosmic-stardust": "other",
+	"gradient-border-fill": "other",
+	"animated-gradient-border-fill": "other",
+	"border-bottom-grow": "other",
+	"gradient-text": "other",
+	"text-color-change": "text-colour",
+	"border-color-change": "other",
+	"sketchy-border": "other",
+	"pulse-animation": "other",
+	"nav-underline": "underline",
+	"nav-frosted-base": "other",
+	"nav-frosted-hover": "other",
+	"nav-frosted-active": "other"
+};
+const policiesById = NAV_EFFECT_POLICIES;
+function navEffectPolicy(effectId) {
+	return policiesById[effectId] ?? null;
+}
+
 //#endregion
 //#region ../theme-core/src/navigation/types.ts
 /**
@@ -17102,6 +17228,16 @@ const navLinkStyleSchema = z.object({
 	borderRadius: navLinkBorderRadiusSchema.default("none"),
 	effects: effectCompositionSchema.optional()
 });
+function navLinkHoverColorCandidate(style) {
+	const effect = style?.effects?.hover?.find((item) => navEffectPolicy(item.effectId) === "text-colour");
+	return parseThemeColorToken(effect?.options?.hoverColorToken ?? style?.hoverColorToken);
+}
+function navLinkOwnsHoverForeground(style) {
+	return style?.effects?.hover?.some((effect) => navEffectPolicy(effect.effectId) === "paired-hover") ?? false;
+}
+function navLinkOwnsUnderline(style) {
+	return style?.effects?.hover?.some((effect) => navEffectPolicy(effect.effectId) === "underline") ?? false;
+}
 /**
 * Padding values for nav link padding presets
 */
@@ -22908,6 +23044,17 @@ function reinterpretForSiteStyle(input) {
 	};
 }
 
+//#endregion
+//#region ../theme-core/src/header/rootPaint.ts
+/** The nav container takes precedence when a floating header also has one. */
+function headerRootPaint(header) {
+	const navContainerType = header?.navContainer?.type ?? "none";
+	if (navContainerType === "glass" || navContainerType === "pill") {
+		return "contained-nav";
+	}
+	return header?.variant === "floating" ? "overlay" : "own-surface";
+}
+
 //#endregion
 //#region ../theme-core/src/site-styles/siteChromeBackgrounds.ts
 const siteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceColorTokenNames);
@@ -22942,8 +23089,7 @@ function canCustomizeSiteChromeBackground(theme, surface$1) {
 	if (surface$1 === "footer") return true;
 	const header = theme?.header;
 	if (!header) return false;
-	const navContainerType = header.navContainer?.type ?? "none";
-	return header.variant !== "floating" && navContainerType !== "glass" && navContainerType !== "pill";
+	return headerRootPaint(header) === "own-surface";
 }
 function siteChromeBackgroundOverrideLabel(override) {
 	switch (override.kind) {
@@ -23009,19 +23155,10 @@ function siteChromeBackgroundOverrideFromBackground(background) {
 function applyHeaderBackgroundOverride(theme, header, override) {
 	if (override.kind === "default") return header;
 	const background = siteChromeColorBackground(override.token);
-	const foreground = resolveChromeForegroundToken(theme, background);
+	assertChromeBackgroundHasForeground(theme, background);
 	return {
 		...header,
-		background: {
-			...background,
-			textColor: foreground
-		},
-		textColor: foreground,
-		navColor: foreground,
-		...header.navLinkStyle ? { navLinkStyle: {
-			...header.navLinkStyle,
-			colorToken: foreground
-		} } : {}
+		background
 	};
 }
 /**
@@ -23033,34 +23170,17 @@ function applyHeaderBackgroundOverride(theme, header, override) {
 function applyFooterBackgroundOverride(theme, footer, override) {
 	if (override.kind === "default") return footer;
 	const background = siteChromeColorBackground(override.token);
-	const foreground = resolveChromeForegroundToken(theme, background);
+	assertChromeBackgroundHasForeground(theme, background);
 	return {
 		...footer,
-		background: {
-			...background,
-			textColor: foreground
-		},
-		navColor: foreground,
-		...footer.navLinkStyle ? { navLinkStyle: {
-			...footer.navLinkStyle,
-			colorToken: foreground
-		} } : {},
-		...footer.bottomTextLinkStyle ? { bottomTextLinkStyle: {
-			...footer.bottomTextLinkStyle,
-			colorToken: foreground
-		} } : {},
-		...footer.bottomBar ? { bottomBar: {
-			...footer.bottomBar,
-			textColor: foreground
-		} } : {}
+		background
 	};
 }
-function resolveChromeForegroundToken(theme, background) {
+function assertChromeBackgroundHasForeground(theme, background) {
 	const resolved = resolveSurfaceForeground(background, expandPalette(theme.palette));
 	if (resolved.kind === "unknown") {
 		throw new Error(`Site chrome background "${background?.type === "color" ? background.color ?? "unknown" : "unknown"}" has no resolvable AA foreground; the theme palette is incomplete`);
 	}
-	return resolved.roles.text;
 }
 function siteChromeColorBackground(color) {
 	return {
@@ -25209,12 +25329,261 @@ function compareCompiledHeaders(left, right) {
 	};
 }
 
+//#endregion
+//#region ../theme-core/src/navigation/presets.ts
+/**
+* Built-in nav link style presets
+*
+* Each preset uses composable effects to achieve its look.
+*/
+const NAV_LINK_PRESETS = {
+	minimal: {
+		name: "Minimal",
+		typography: "body",
+		fontWeight: "medium",
+		textTransform: "none",
+		italic: false,
+		colorToken: "text",
+		hoverColorToken: "primary",
+		padding: "none",
+		borderRadius: "none",
+		effects: { hover: [{
+			effectId: "text-color-change",
+			options: { hoverColorToken: "primary" }
+		}] }
+	},
+	underline: {
+		name: "Underline",
+		typography: "body",
+		fontWeight: "medium",
+		textTransform: "none",
+		italic: false,
+		colorToken: "text",
+		padding: "none",
+		borderRadius: "none",
+		effects: { hover: [{
+			effectId: "nav-underline",
+			options: { style: "static" }
+		}] }
+	},
+	"underline-grow": {
+		name: "Underline Grow",
+		typography: "body",
+		fontWeight: "medium",
+		textTransform: "none",
+		italic: false,
+		colorToken: "text",
+		padding: "none",
+		borderRadius: "none",
+		effects: { hover: [{
+			effectId: "nav-underline",
+			options: { style: "grow" }
+		}] }
+	},
+	capsule: {
+		name: "Capsule",
+		typography: "body",
+		fontWeight: "medium",
+		textTransform: "none",
+		italic: false,
+		colorToken: "text",
+		padding: "compact",
+		borderRadius: "full",
+		effects: {
+			hover: [{
+				effectId: "background-on-hover-alpha",
+				options: {
+					colorToken: "primary",
+					opacity: 10
+				}
+			}],
+			active: [{
+				effectId: "background-on-hover-alpha",
+				options: {
+					colorToken: "primary",
+					opacity: 15
+				}
+			}]
+		}
+	},
+	solid: {
+		name: "Solid",
+		typography: "body",
+		fontWeight: "medium",
+		textTransform: "none",
+		italic: false,
+		colorToken: "text",
+		padding: "compact",
+		borderRadius: "none",
+		effects: {
+			hover: [{
+				effectId: "background-on-hover",
+				options: {
+					colorToken: "primary",
+					textColorToken: "primaryForeground"
+				}
+			}],
+			active: [{
+				effectId: "background-on-hover",
+				options: {
+					colorToken: "primary",
+					textColorToken: "primaryForeground"
+				}
+			}]
+		}
+	},
+	scale: {
+		name: "Scale",
+		typography: "body",
+		fontWeight: "medium",
+		textTransform: "none",
+		italic: false,
+		colorToken: "text",
+		padding: "none",
+		borderRadius: "none",
+		effects: { hover: [{
+			effectId: "scale-up",
+			options: { scale: 1.05 }
+		}] }
+	},
+	frosted: {
+		name: "Frosted",
+		typography: "body",
+		fontWeight: "medium",
+		textTransform: "none",
+		italic: false,
+		colorToken: "text",
+		padding: "compact",
+		borderRadius: "md",
+		effects: {
+			base: [{ effectId: "nav-frosted-base" }],
+			hover: [{ effectId: "nav-frosted-hover" }],
+			active: [{ effectId: "nav-frosted-active" }]
+		}
+	}
+};
+/**
+* Get a nav link style preset by ID
+*/
+function getNavLinkPreset(presetId) {
+	return NAV_LINK_PRESETS[presetId];
+}
+/**
+* List of available preset IDs
+*/
+const NAV_LINK_PRESET_IDS = Object.keys(NAV_LINK_PRESETS);
+
+//#endregion
+//#region ../theme-core/src/header/legacyNavLinkStyle.ts
+function buildLegacyHeaderNavLinkStyle(header, contrastTreatment, navTextSize) {
+	const navStyle = header.navStyle ?? "minimal";
+	const basePreset = getNavLinkPreset(navStyle);
+	if (!basePreset) return null;
+	const style = {
+		...basePreset,
+		fontWeight: header.navWeight ?? basePreset.fontWeight,
+		colorToken: (header.navColor ?? header.textColor)?.trim() || basePreset.colorToken,
+		...contrastTreatment ? { contrastTreatment } : {},
+		...navTextSize ? { textSize: navTextSize } : {}
+	};
+	if (header.navWeight === "bold" && navStyle === "solid") {
+		style.textTransform = "uppercase";
+	}
+	applyLegacyGlassTreatment(style, header, navStyle);
+	return style;
+}
+function applyLegacyGlassTreatment(style, header, navStyle) {
+	if (header.navContainer?.type !== "glass" || navStyle !== "minimal") return;
+	style.borderRadius = "full";
+	style.effects = {
+		...style.effects,
+		hover: glassStateEffects(10),
+		active: glassStateEffects(18)
+	};
+}
+function glassStateEffects(opacity) {
+	return [{
+		effectId: "background-on-hover-alpha",
+		options: {
+			colorToken: "neutral-50",
+			opacity
+		}
+	}, {
+		effectId: "text-color-change",
+		options: { hoverColorToken: "neutral-50" }
+	}];
+}
+
+//#endregion
+//#region ../theme-core/src/header/openingForegroundProjection.ts
+/** Page-scoped render data. It is deliberately absent from the persisted theme schema. */
+function withOpeningForegroundProjection(header, foreground) {
+	const projected = {
+		...header,
+		__runtimeOpeningForeground: foreground
+	};
+	return projected;
+}
+function readOpeningForegroundProjection(header) {
+	return header?.__runtimeOpeningForeground ?? null;
+}
+
+//#endregion
+//#region ../theme-core/src/header/effectiveNavLinkStyle.ts
+function effectiveHeaderNavLinkStyle(header, contrastTreatment = null, navTextSize = null) {
+	if (!header) return null;
+	if (!header.navLinkStyle) {
+		return buildLegacyHeaderNavLinkStyle(header, contrastTreatment, navTextSize);
+	}
+	return {
+		...header.navLinkStyle,
+		...contrastTreatment ? { contrastTreatment } : {},
+		...navTextSize ? { textSize: navTextSize } : {}
+	};
+}
+function headerForegroundCandidates(header) {
+	if (!header) return {};
+	const style = effectiveHeaderNavLinkStyle(header);
+	return {
+		text: header.textColor ?? header.background?.textColor,
+		link: style?.colorToken ?? header.navColor ?? header.textColor,
+		linkHover: navLinkHoverColorCandidate(style)
+	};
+}
+function headerLeafTextColor(header) {
+	if (!header) return "text";
+	return header.textColor ?? header.navColor ?? header.background?.textColor ?? header.navLinkStyle?.colorToken ?? "text";
+}
+/** Transparent chrome must reset the whole contract on its own root. */
+function transparentHeaderForegroundInput(header, palette) {
+	const projection = readOpeningForegroundProjection(header);
+	if (projection?.kind === "known") {
+		return surfaceForegroundInputFromResolved(projection, rgbColorValue);
+	}
+	return authoredTransparentHeaderForegroundInput(header, palette);
+}
+function authoredTransparentHeaderForegroundInput(header, palette) {
+	const text = headerLeafTextColor(header);
+	const style = effectiveHeaderNavLinkStyle(header);
+	const link = style?.colorToken ?? text;
+	const restingToken = parseThemeColorToken(link) ?? parseThemeColorToken("text");
+	if (!restingToken) throw new Error("Built-in text colour token is invalid");
+	const hover = planForegroundHover({
+		restingToken,
+		candidate: navLinkOwnsHoverForeground(style) ? null : navLinkHoverColorCandidate(style),
+		palette,
+		backdrops: null
+	});
+	return {
+		text: rgbColorValue(text),
+		link: rgbColorValue(link),
+		linkHover: rgbColorValue(hover.token),
+		hoverDecoration: navLinkOwnsUnderline(style) ? "initial" : hover.decoration
+	};
+}
+
 //#endregion
 //#region ../theme-core/src/site-styles/headerOpeningForeground.ts
-/** The nav-link hover effect that is a plain colour change. */
-const TEXT_COLOR_CHANGE_EFFECT_ID = "text-color-change";
-/** The nav-link hover affordance that does not depend on a colour delta. */
-const NAV_UNDERLINE_EFFECT_ID = "nav-underline";
 function headerStyleAvailability(recipe, context) {
 	if (!recipe.openingForeground) return { kind: "available" };
 	return context?.openingForeground?.kind === "known" ? { kind: "available" } : {
@@ -25231,17 +25600,33 @@ function headerStyleAvailabilityReasonLabel(reason) {
 function applyOpeningForeground(theme, header, recipe, context) {
 	if (!recipe.openingForeground) return header;
 	const foreground = context?.openingForeground ?? { kind: "unknown" };
-	if (foreground.kind === "unknown") return applyUnknownOpeningForegroundFallback(header);
+	if (foreground.kind === "unknown") return withOpeningForegroundProjection(applyUnknownOpeningForegroundFallback(theme, header), foreground);
+	return projectKnownOpeningForeground(theme, header, recipe, foreground);
+}
+function projectKnownOpeningForeground(theme, header, recipe, foreground) {
 	const withBrandForeground = {
 		...header,
 		textColor: foreground.roles.text
 	};
 	if (recipe.openingForeground === "brand-only") return withBrandForeground;
 	const scrollTreatment = compileHeaderScrollTreatment(theme, recipe, foreground.roles.text);
-	return {
+	const style = effectiveHeaderNavLinkStyle(header);
+	const hoverPlan = style && !navLinkOwnsHoverForeground(style) ? planOpeningNavHover(theme, foreground, style, scrollTreatment) : null;
+	const projectedForeground = hoverPlan ? {
+		...foreground,
+		roles: {
+			...foreground.roles,
+			linkHover: hoverPlan.token
+		},
+		hoverDecoration: hoverPlan.decoration
+	} : foreground;
+	return withOpeningForegroundProjection({
 		...withBrandForeground,
 		navColor: foreground.roles.text,
-		navLinkStyle: header.navLinkStyle ? adaptNavLinkStyleToForeground(header.navLinkStyle, foreground.roles.link, planForegroundHover(foreground.roles.link, paletteHexForToken(theme, foreground.roles.link), scrollTreatment?.kind === "contrast-glass" ? scrollTreatment.backgroundTone : null)) : header.navLinkStyle,
+		navLinkStyle: style ? navLinkOwnsHoverForeground(style) ? {
+			...style,
+			colorToken: foreground.roles.link
+		} : projectOpeningTextNavStyle(style, foreground.roles.link) : header.navLinkStyle,
 		border: {
 			style: "solid",
 			width: "thin",
@@ -25249,79 +25634,52 @@ function applyOpeningForeground(theme, header, recipe, context) {
 			colorToken: parseThemeColorToken(`${foreground.roles.text}/25`) ?? foreground.roles.text
 		},
 		...scrollTreatment ? { scrollTreatment } : {}
-	};
-}
-/**
-* Give the resolved foreground both the resting and the hover colour.
-*
-* Adapting the resting colour alone left hover as whatever the recipe wrote —
-* for `minimal-surface` a bare `primary`, which is a brand colour no one had
-* checked against the section the header floats over. On a primary-painted
-* opening section that resolves to the section's own colour, and the link
-* disappears on hover.
-*
-* The two colours are a pair: the scroll treatment picks its glass tone from
-* the resting foreground precisely so one colour reads both against the opening
-* section and against the glass. A hover colour outside that pairing is not
-* covered by either half of it.
-*
-* A pill palette is left alone. It owns hover through `background-on-hover`,
-* which carries its own paired background and foreground tokens, so hover
-* legibility there does not depend on the surface underneath at all.
-*/
-function adaptNavLinkStyleToForeground(navLinkStyle, linkToken, hoverPlan) {
-	const adapted = {
-		...navLinkStyle,
-		colorToken: linkToken
-	};
-	const hoverEffects = navLinkStyle.effects?.hover ?? [];
-	const hasColorChange = hoverEffects.some(isTextColorChangeEffect);
-	if (!hasColorChange && hoverEffects.length > 0) return adapted;
-	if (!hasColorChange && !navLinkStyle.hoverColorToken) return adapted;
-	const underline = {
-		effectId: NAV_UNDERLINE_EFFECT_ID,
+	}, projectedForeground);
+}
+function planOpeningNavHover(theme, foreground, style, scrollTreatment) {
+	const glassBackdrop = scrollTreatment?.kind === "contrast-glass" ? worstCaseGlassBackdrop(scrollTreatment.backgroundTone) : null;
+	const measured = foreground.provenance.kind === "measured";
+	const candidate$1 = measured ? navLinkHoverColorCandidate(style) : foreground.hoverDecoration === "initial" ? foreground.roles.linkHover : null;
+	const backdrops = measured ? [foreground.provenance.backdropHex, ...glassBackdrop ? [glassBackdrop] : []] : glassBackdrop ? [glassBackdrop] : null;
+	const plan = planForegroundHover({
+		restingToken: foreground.roles.link,
+		candidate: candidate$1,
+		palette: expandPalette(theme.palette),
+		backdrops
+	});
+	return !measured && plan.kind === "softened" ? {
+		kind: "resting",
+		token: foreground.roles.link,
+		decoration: "underline"
+	} : plan;
+}
+/** The surface contract owns colour; the nav effect keeps its grow animation. */
+function projectOpeningTextNavStyle(style, linkToken, requireUnderline = true) {
+	const hover = (style.effects?.hover ?? []).filter((effect) => navEffectPolicy(effect.effectId) !== "text-colour").map((effect) => navEffectPolicy(effect.effectId) === "underline" ? {
+		...effect,
 		options: {
+			...effect.options,
 			style: "grow",
 			colorToken: linkToken
 		}
-	};
-	const withoutColorChange = hoverEffects.filter((effect) => !isTextColorChangeEffect(effect) && !isNavUnderlineEffect(effect));
-	if (hoverPlan.kind === "resting") {
-		return {
-			...adapted,
-			hoverColorToken: null,
-			effects: {
-				...adapted.effects,
-				hover: [...withoutColorChange, underline]
-			}
-		};
-	}
-	const hoverColorToken = hoverPlan.token;
+	} : effect);
+	const needsUnderline = requireUnderline && !navLinkOwnsUnderline({ effects: { hover } });
 	return {
-		...adapted,
-		hoverColorToken,
+		...style,
+		colorToken: linkToken,
+		hoverColorToken: null,
 		effects: {
-			...adapted.effects,
-			hover: [...hoverEffects.map((effect) => isTextColorChangeEffect(effect) ? {
-				...effect,
+			...style.effects,
+			hover: needsUnderline ? [...hover, {
+				effectId: "nav-underline",
 				options: {
-					...effect.options,
-					hoverColorToken
+					style: "grow",
+					colorToken: linkToken
 				}
-			} : effect).filter((effect) => !isNavUnderlineEffect(effect)), underline]
+			}] : hover
 		}
 	};
 }
-function isTextColorChangeEffect(effect) {
-	return effect.effectId === TEXT_COLOR_CHANGE_EFFECT_ID;
-}
-function isNavUnderlineEffect(effect) {
-	return effect.effectId === NAV_UNDERLINE_EFFECT_ID;
-}
-/** Concrete hex behind a plain palette token, or null when it is not one. */
-function paletteHexForToken(theme, token) {
-	return opaquePaletteHexForToken(expandPalette(theme.palette), token);
-}
 function compileHeaderScrollTreatment(theme, recipe, foregroundToken) {
 	if (recipe.scrollTreatment !== "contrast-glass") return undefined;
 	const tokenParts = parseColorTokenParts(foregroundToken);
@@ -25347,19 +25705,37 @@ const UNKNOWN_OPENING_FOREGROUND_CONTAINER = {
 * keeps already-persisted selections readable without creating a second
 * availability policy.
 */
-function applyUnknownOpeningForegroundFallback(header) {
+function applyUnknownOpeningForegroundFallback(theme, header) {
+	const textToken = parseThemeColorToken("text");
+	if (!textToken) throw new Error("Built-in text colour token is invalid");
+	const style = effectiveHeaderNavLinkStyle(header);
+	const plannedHover = style && !navLinkOwnsHoverForeground(style) ? planUnknownOpeningNavHover(theme, style, textToken) : null;
 	return {
 		...header,
 		scrollTreatment: undefined,
 		textColor: "text",
 		navColor: "text",
-		navLinkStyle: header.navLinkStyle ? {
-			...header.navLinkStyle,
-			colorToken: "text"
+		navLinkStyle: style ? navLinkOwnsHoverForeground(style) ? {
+			...style,
+			colorToken: textToken
+		} : {
+			...projectOpeningTextNavStyle(style, textToken, plannedHover?.kind === "resting"),
+			hoverColorToken: plannedHover?.kind === "resting" ? null : plannedHover?.token
 		} : header.navLinkStyle,
 		container: UNKNOWN_OPENING_FOREGROUND_CONTAINER
 	};
 }
+function planUnknownOpeningNavHover(theme, style, restingToken) {
+	const palette = expandPalette(theme.palette);
+	const surface$1 = palette.surface;
+	const backdrops = surface$1 ? [compositeHex(surface$1, "#000000", UNKNOWN_OPENING_FOREGROUND_CONTAINER.opacity), compositeHex(surface$1, "#ffffff", UNKNOWN_OPENING_FOREGROUND_CONTAINER.opacity)] : null;
+	return planForegroundHover({
+		restingToken,
+		candidate: surface$1 ? navLinkHoverColorCandidate(style) : null,
+		palette,
+		backdrops
+	});
+}
 function applyPageOpeningForegroundToTheme(theme, recipe, context) {
 	if (!recipe?.openingForeground) return theme;
 	return {
@@ -29737,9 +30113,11 @@ const coursePolicyOverrideSchema = z.object({
 	cutoffHours: z.number().int().nonnegative().optional()
 }).strict();
 /**
-* The four booking settings a course owns for every one of its runs: where it
-* is listed, whether passes and memberships may be used, and the refunds and
-* transfers policy.
+* The booking settings a course owns for every one of its runs: where it is
+* listed, whether passes and memberships may be used, QR tickets
+* (`ticketingMode`, where `inherit` follows the course's event type), guest
+* details (`collectAllAttendeeDetails`, where `null` follows the event type)
+* and the refunds and transfers policy.
 *
 * Listing is spelled the way the management API spells it ('public' or
 * 'unlisted') rather than in the command language, which folds "not live yet"
@@ -29750,6 +30128,12 @@ const courseBookingSettingsSchema = z.object({
 	visibility: z.enum(["public", "unlisted"]),
 	acceptsPasses: z.boolean(),
 	acceptsMemberships: z.boolean(),
+	ticketingMode: z.enum([
+		"inherit",
+		"enabled",
+		"disabled"
+	]).optional(),
+	collectAllAttendeeDetails: z.boolean().nullable().optional(),
 	cancellationPolicy: z.object({
 		refunds: coursePolicyOverrideSchema,
 		transfers: coursePolicyOverrideSchema
@@ -30753,7 +31137,6 @@ const upsertEventSeriesCommandSchema = z.object({
 		occurrences: z.array(eventOccurrenceSchema).min(1).readonly(),
 		content: contentSummarySchema.optional(),
 		settings: unknownRecordSchema.optional(),
-		presentation: unknownRecordSchema.nullable().optional(),
 		tags: z.array(z.string()).readonly().optional(),
 		blocks: entrySlotBlocksSchema.optional(),
 		staffRefs: z.array(staffRefSchema).readonly().optional()
@@ -30983,7 +31366,6 @@ const allowedRuntimes = [
 const intendedExposures = [
 	"recipe",
 	"sdk_cli",
-	"onboarding_planner",
 	"ai_proposal",
 	"internal_apply"
 ];
@@ -31025,21 +31407,15 @@ const allRuntimes = [
 const standardExposure = [
 	"recipe",
 	"sdk_cli",
-	"onboarding_planner",
 	"internal_apply"
 ];
 const proposalExposure = [
 	"recipe",
 	"sdk_cli",
-	"onboarding_planner",
 	"ai_proposal",
 	"internal_apply"
 ];
-const recipeExposure = [
-	"recipe",
-	"onboarding_planner",
-	"internal_apply"
-];
+const recipeExposure = ["recipe", "internal_apply"];
 const sdkExposure = ["sdk_cli", "internal_apply"];
 
 //#endregion
@@ -31732,6 +32108,18 @@ function isIdentifiedImage(image) {
 	return typeof image === "object" && image !== null && typeof image.identifier === "string" && image.identifier.trim().length > 0;
 }
 
+//#endregion
+//#region ../site-commands/src/planCommandOrderingDependencies.ts
+/** A complete reorder observes the membership after all selected page mutations. */
+function planCommandOrderingDependencies(command, commands, providerByRef, requiresByCommand) {
+	const referenced = (requiresByCommand.get(command.ref) ?? []).flatMap(({ ref }) => {
+		const provider = providerByRef.get(ref);
+		return provider === undefined ? [] : [provider];
+	});
+	const membership = command.type === "reorderPageBlocks" ? commands.filter((candidate$1) => (candidate$1.type === "upsertPageBlock" || candidate$1.type === "deletePageBlock") && candidate$1.input.pageIdentifier === command.input.pageIdentifier).map((candidate$1) => candidate$1.ref) : [];
+	return [...new Set([...referenced, ...membership])];
+}
+
 //#endregion
 //#region ../site-commands/src/guards.ts
 function isRecord(value) {
@@ -32161,13 +32549,12 @@ const unsupportedWholeSeriesPageFieldChecks = [
 	(input) => input.categoryRef !== undefined,
 	(input) => input.categoryIdentifier !== undefined,
 	(input) => input.tags !== undefined,
-	(input) => input.presentation !== undefined,
 	(input) => input.content?.imageRef !== undefined,
 	(input) => input.content?.mediaRefs !== undefined
 ];
 function wholeSeriesPageFieldsGap(input) {
 	if (!unsupportedWholeSeriesPageFieldChecks.some((hasField) => hasField(input))) return null;
-	return staticGap("event_whole_series_page_fields_unsupported", "Whole-series page, reference, tag, and presentation fields need native page-authority mapping before mutation.");
+	return staticGap("event_whole_series_page_fields_unsupported", "Whole-series page, reference and tag fields need native page-authority mapping before mutation.");
 }
 function passesGap(input) {
 	return input.bookingOffer.pricing.acceptsPasses === true ? staticGap("event_whole_series_passes_unsupported", "Whole-series commands do not support pass redemption.") : null;
@@ -32581,10 +32968,9 @@ function orderCommands(commands, providerByRef, requiresByCommand) {
 	const outgoing = new Map();
 	const indegree = new Map(commands.map((command) => [command.ref, 0]));
 	for (const command of commands) {
-		const requires = requiresByCommand.get(command.ref) ?? [];
-		for (const { ref } of requires) {
-			const provider = providerByRef.get(ref);
-			if (provider === undefined || provider === command.ref) continue;
+		const providers = planCommandOrderingDependencies(command, commands, providerByRef, requiresByCommand);
+		for (const provider of providers) {
+			if (provider === command.ref) continue;
 			if (!outgoing.has(provider)) outgoing.set(provider, new Set());
 			const dependents = outgoing.get(provider);
 			if (dependents !== undefined && !dependents.has(command.ref)) {
@@ -33325,4 +33711,4 @@ function parseSdkEventRunUpsertInput(input, runIndex, options) {
 }
 
 //#endregion
-export { BREAKPOINT_MD as $, defaultThemeTokens as $n, parseGradientPresetId as $t, createBlockRef as A, cardVariantRoleValues as An, resolvedButtonFocusDeclarations as At, createSiteCommandSiteRef as B, rgbColorValue as Bn, themeButtonExtraClassesWithTrailingIcon as Bt, pagePathForCommand as C, mediaTypeDiscriminants as Cn, featuresFromHex as Cr, ACCORDION_TRIGGER_FONT_SCALE as Ct, require_react as D, generateCardCss as Dn, generateButtonCss as Dt, require_jsx_runtime as E, getDefaultCardVariants as En, __toESM as Er, ICON_SIZE_PX as Et, createEventSeriesRef as F, TokenResolver as Fn, generateDefaultButtonSystem as Ft, readHeaderNavFontSizePreference as G, resolveSurfaceForeground as Gn, formatButtonColourContractError as Gt, refSlug as H, textColorValue as Hn, themeButtonVariantClassNames as Ht, createFooterRef as I, backgroundColorStyle as In, generateEffectsCSS as It, generateHeaderScrollTreatmentStyles as J, surfaceForegroundStyle as Jn, getTextColorForBackground as Jt, getCuratedSiteStyle as K, DEFAULT_SURFACE_TEXT_COLOR as Kn, generateShadowValue as Kt, createFormRef as L, borderColorStyle as Ln, generateBaseInteractiveCSS as Lt, createCommandRef as M, backgroundAppearanceColorTokenNames as Mn, contextualButtonSurfaceStyles as Mt, createContentEntryRef as N, backgroundAppearanceQuickColorTokenNames as Nn, deriveButtonSurfaceContext as Nt, pickShadeTowardBackground as O, generateShadowValue$1 as On, RESOLVED_BUTTON_DISABLED_DECLARATIONS as Ot, createEventCategoryRef as P, parseBackgroundAppearanceColorToken as Pn, resolveContextualButtonRole as Pt, BREAKPOINT_LG as Q, buildThemeTokens as Qn, getGradientPreset as Qt, createNavigationRef as R, cssVarValue as Rn, generateInteractiveChildInheritanceCSS as Rt, pageIdentifierForCommand as S, mediaSchema as Sn, contrastRatio as Sr, ACCORDION_SPACING_MAP as St, eventBookingOfferIntentSchema as T, generateCardCoreCss as Tn, oklchToHexGamut as Tr, ICON_CONFIG as Tt, slugPart as U, selectLogoVariant as Un, parseThemeForPersistence as Ut, createVenueRef as V, textColorStyle as Vn, themeButtonSizeClassName as Vt, mergeHeaderNavTypographyPreference as W, surfaceToneFromForegroundToken as Wn, compileButtonColourStates as Wt, getHeaderPaintTargets as X, parseBlockColorToken as Xn, gradientToCss as Xt, generateMobileOverlayBackdropFilterFix as Y, surfaceForegroundValue as Yn, footerModeSchema as Yt, renderHeaderPaintTargetRules as Z, parseColorTokenParts as Zn, GRADIENT_PRESET_IDS as Zt, getSiteCommandMetadata as _, resolveThemeColorReferenceValue as _n, tileTreatmentValues as _r, FONT_WEIGHT_MAP as _t, classifySdkEventSchedule as a, pageDesignBoundaryTreatmentSchema as an, assertNever$1 as ar, MQ_SM_UP as at, entryIdentifierForCommand as b, stripStaleTransitionStyleGroup as bn, onColorTokenName as br, LABEL_FONT_SIZE_MAP as bt, isEventVisibility as c, composeBoundary as cn, defineNoBlockDesignCapability as cr, getComponentBorderWidthPx as ct, stableStringify as d, anglePolygonCss as dn, featureCardCompositionTreatmentValues as dr, parseCustomCssRules as dt, buttonStyleSelectionSchema as en, defineBlockDesignMetadata as er, BREAKPOINT_SM as et, createDryRunReport as f, transitionCatalogueEntries as fn, headingDecorationColorTokenValues as fr, NAV_LINK_BORDER_RADIUS_MAP as ft, evaluateSiteCommandExposure as g, resolveOnColorForThemeToken as gn, testimonialsCompositionTreatmentValues as gr, NAV_LINK_TEXT_SIZE_MAP as gt, evaluateSiteCommandBatchExposure as h, isCssColorLiteral as hn, offeringsPreviewCompositionTreatmentValues as hr, NAV_LINK_PADDING_X_MAP as ht, sdkEventUpsertOptionalFieldSchemas as i, unsafeAsOpaqueButtonColourToken as in, asSiteStyleId as ir, MQ_SM_DOWN as it, createBlocksRef as j, normalizeCardRole as jn, contextualButtonSurfaceResetStyles as jt, generateCssVars as k, cardRoleSchema as kn, resolvedButtonColourDeclarations as kt, venueManagementFields as l, sectionFactsForContent as ln, eventListTreatmentValues as lr, getComponentShadowVar as lt, mapEventCommandContent as m, boxBackgroundSchema as mn, makeBoundaryId as mr, NAV_LINK_PADDING_MAP as mt, sdkCourseBookingSettingsSchema as n, VARIANT_ROLES as nn, asDesignBlockId as nr, MQ_LG_UP as nt, classifySdkEventBookingOffer as o, pageDesignIntentSchemaVersion as on, defineBlockDesignCapability as or, MQ_TABLET_ONLY as ot, parseAndPlanCommandBatchForTypes as p, boxBackgroundOverlaySchema as pn, introCompositionTreatmentValues as pr, NAV_LINK_LETTER_SPACING_MAP as pt, themeSchema as q, surfaceForegroundDeclarations as qn, expandPalette as qt, sdkEventOccurrenceInputSchema as r, buttonVariantIdSchema as rn, asPageFlowPresetId as rr, MQ_MD_DOWN as rt, eventVisibilitySchema as s, boundaryLayout as sn, defineFrameCapability as sr, headerVariantValues as st, classifySdkEventTiming as t, PUBLIC_BUTTON_ROLES as tn, asAppearancePresetId as tr, BREAKPOINT_XL as tt, sortRecord as u, boundaryRuntimeMetricsForDecorativeTransition as un, eyebrowTreatmentValues as ur, parseBlockCustomCssRules as ut, blockIdentifierForCommand as v, resolveTokenOrCssColorValue as vn, visibleHeadingDecorationFamilyValues as vr, INPUT_FONT_SIZE_MAP as vt, hasConfiguredBookingVertical as w, persistableMediaSchema as wn, hexToRgb as wr, ACCORDION_TRIGGER_LETTER_SPACING as wt, pageIdentifierForBlockCommand as x, mediaIdentifierSchema as xn, ORDINARY_TEXT_MIN_CONTRAST_RATIO as xr, ACCORDION_OPEN_ACCENT_THICKNESS as xt, blockOrderIdentifiersForCommand as y, pageDesignEditorBackgroundOverrideOwner as yn, isOnColorBackgroundCandidateToken as yr, INPUT_SPACING_MAP as yt, createPageRef as z, mergeStyles as zn, parseThemeButtonVariantId as zt };
+export { getCuratedSiteStyle as $, rgbColorValue as $n, themeButtonVariantClassNames as $t, createBlockRef as A, stripStaleTransitionStyleGroup as An, offeringsPreviewCompositionTreatmentValues as Ar, INPUT_SPACING_MAP as At, createSiteCommandSiteRef as B, getTextColorForBackground as Bn, oklchToHexGamut as Br, resolvedButtonColourDeclarations as Bt, pagePathForCommand as C, boxBackgroundSchema as Cn, defineNoBlockDesignCapability as Cr, NAV_LINK_TEXT_SIZE_MAP as Ct, require_react as D, resolveTokenOrCssColorValue as Dn, headingDecorationColorTokenValues as Dr, navEffectPolicy as Dt, require_jsx_runtime as E, resolveThemeColorReferenceValue as En, featureCardCompositionTreatmentValues as Er, navLinkOwnsUnderline as Et, createEventSeriesRef as F, generateCardCoreCss as Fn, onColorTokenName as Fr, ACCORDION_TRIGGER_LETTER_SPACING as Ft, headerForegroundCandidates as G, backgroundAppearanceColorTokenNames as Gn, resolveContextualButtonRole as Gt, refSlug as H, cardRoleSchema as Hn, contextualButtonSurfaceResetStyles as Ht, createFooterRef as I, getDefaultCardVariants as In, ORDINARY_TEXT_MIN_CONTRAST_RATIO as Ir, ICON_CONFIG as It, readOpeningForegroundProjection as J, TokenResolver as Jn, generateBaseInteractiveCSS as Jt, headerLeafTextColor as K, backgroundAppearanceQuickColorTokenNames as Kn, generateDefaultButtonSystem as Kt, createFormRef as L, generateCardCss as Ln, contrastRatio as Lr, ICON_SIZE_PX as Lt, createCommandRef as M, mediaSchema as Mn, tileTreatmentValues as Mr, ACCORDION_OPEN_ACCENT_THICKNESS as Mt, createContentEntryRef as N, mediaTypeDiscriminants as Nn, visibleHeadingDecorationFamilyValues as Nr, ACCORDION_SPACING_MAP as Nt, pickShadeTowardBackground as O, pageDesignEditorBackgroundOverrideOwner as On, introCompositionTreatmentValues as Or, FONT_WEIGHT_MAP as Ot, createEventCategoryRef as P, persistableMediaSchema as Pn, isOnColorBackgroundCandidateToken as Pr, ACCORDION_TRIGGER_FONT_SCALE as Pt, headerRootPaint as Q, mergeStyles as Qn, themeButtonSizeClassName as Qt, createNavigationRef as R, renderCssDeclarations as Rn, featuresFromHex as Rr, generateButtonCss as Rt, pageIdentifierForCommand as S, boxBackgroundOverlaySchema as Sn, defineFrameCapability as Sr, NAV_LINK_PADDING_X_MAP as St, eventBookingOfferIntentSchema as T, resolveOnColorForThemeToken as Tn, eyebrowTreatmentValues as Tr, navLinkOwnsHoverForeground as Tt, slugPart as U, cardVariantRoleValues as Un, contextualButtonSurfaceStyles as Ut, createVenueRef as V, generateShadowValue$1 as Vn, __toESM as Vr, resolvedButtonFocusDeclarations as Vt, effectiveHeaderNavLinkStyle as W, normalizeCardRole as Wn, deriveButtonSurfaceContext as Wt, mergeHeaderNavTypographyPreference as X, borderColorStyle as Xn, parseThemeButtonVariantId as Xt, getNavLinkPreset as Y, backgroundColorStyle as Yn, generateInteractiveChildInheritanceCSS as Yt, readHeaderNavFontSizePreference as Z, cssVarValue as Zn, themeButtonExtraClassesWithTrailingIcon as Zt, getSiteCommandMetadata as _, composeBoundary as _n, asDesignBlockId as _r, parseBlockCustomCssRules as _t, classifySdkEventSchedule as a, gradientToCss as an, DEFAULT_SURFACE_TEXT_COLOR as ar, BREAKPOINT_LG as at, entryIdentifierForCommand as b, anglePolygonCss as bn, assertNever$1 as br, NAV_LINK_LETTER_SPACING_MAP as bt, isEventVisibility as c, parseGradientPresetId as cn, surfaceForegroundStyle as cr, BREAKPOINT_XL as ct, stableStringify as d, VARIANT_ROLES as dn, parseBlockColorToken as dr, MQ_SM_DOWN as dt, parseThemeForPersistence as en, textColorStyle as er, themeSchema as et, createDryRunReport as f, buttonVariantIdSchema as fn, parseColorTokenParts as fr, MQ_SM_UP as ft, evaluateSiteCommandExposure as g, boundaryLayout as gn, asAppearancePresetId as gr, getComponentShadowVar as gt, evaluateSiteCommandBatchExposure as h, pageDesignIntentSchemaVersion as hn, defineBlockDesignMetadata as hr, getComponentBorderWidthPx as ht, sdkEventUpsertOptionalFieldSchemas as i, footerModeSchema as in, resolveSurfaceForeground as ir, renderHeaderPaintTargetRules as it, createBlocksRef as j, mediaIdentifierSchema as jn, testimonialsCompositionTreatmentValues as jr, LABEL_FONT_SIZE_MAP as jt, generateCssVars as k, siteChromeBackgroundOverrideOwner as kn, makeBoundaryId as kr, INPUT_FONT_SIZE_MAP as kt, venueManagementFields as l, buttonStyleSelectionSchema as ln, surfaceForegroundValue as lr, MQ_LG_UP as lt, mapEventCommandContent as m, pageDesignBoundaryTreatmentSchema as mn, defaultThemeTokens as mr, headerVariantValues as mt, sdkCourseBookingSettingsSchema as n, formatButtonColourContractError as nn, selectLogoVariant as nr, generateMobileOverlayBackdropFilterFix as nt, classifySdkEventBookingOffer as o, GRADIENT_PRESET_IDS as on, surfaceForegroundDeclarations as or, BREAKPOINT_MD as ot, parseAndPlanCommandBatchForTypes as p, unsafeAsOpaqueButtonColourToken as pn, buildThemeTokens as pr, MQ_TABLET_ONLY as pt, transparentHeaderForegroundInput as q, parseBackgroundAppearanceColorToken as qn, generateEffectsCSS as qt, sdkEventOccurrenceInputSchema as r, generateShadowValue as rn, surfaceToneFromForegroundToken as rr, getHeaderPaintTargets as rt, eventVisibilitySchema as s, getGradientPreset as sn, surfaceForegroundInputFromResolved as sr, BREAKPOINT_SM as st, classifySdkEventTiming as t, compileButtonColourStates as tn, textColorValue as tr, generateHeaderScrollTreatmentStyles as tt, sortRecord as u, PUBLIC_BUTTON_ROLES as un, parseThemeColorToken as ur, MQ_MD_DOWN as ut, blockIdentifierForCommand as v, sectionFactsForContent as vn, asPageFlowPresetId as vr, parseCustomCssRules as vt, hasConfiguredBookingVertical as w, isCssColorLiteral as wn, eventListTreatmentValues as wr, navLinkHoverColorCandidate as wt, pageIdentifierForBlockCommand as x, transitionCatalogueEntries as xn, defineBlockDesignCapability as xr, NAV_LINK_PADDING_MAP as xt, blockOrderIdentifiersForCommand as y, boundaryRuntimeMetricsForDecorativeTransition as yn, asSiteStyleId as yr, NAV_LINK_BORDER_RADIUS_MAP as yt, createPageRef as z, expandPalette as zn, hexToRgb as zr, RESOLVED_BUTTON_DISABLED_DECLARATIONS as zt };