riverbankcms 0.25.0 → 0.26.0

package/dist/{sdk-event-upsert-4t4e1z-h.mjs → sdk-event-upsert-CH3xwzuX.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $n as ok, An as unsafeAsEntitlementId, B as parsePublicContactDetails, Bn as unsafeAsPositiveSeconds, Dn as unsafeAsDeclaredMimeType, Et as validateBookingPaymentOptionKinds, Fn as unsafeAsMediaAssetId, Gn as unsafeAsSiteId, Hn as unsafeAsProductId, Jn as unsafeAsStorageBucketName, K as locationValueSchema, Kn as unsafeAsSiteScopedStoragePath, Ln as unsafeAsOriginalFilename, N as parseFooterCompositionV1, P as footerNavigationLayouts, Pn as unsafeAsFileChecksumSha256, Q as isPresent, Qn as err, Qt as mapReadonlyNonEmptyArray, R as isCanonicalRichTextDoc, Tn as unsafeAsBookingSessionId, Tt as parseBookingTimeZone, Un as unsafeAsSafeDownloadFilename, V as parseWeeklyOpeningHours, W as stableJsonStringify, Wn as unsafeAsSiteFontId, Xn as unsafeAsUploadSessionId, Xt as fromArray, Yn as unsafeAsStoragePath, Zn as unsafeAsUserId, Zt as mapNonEmptyArray, a as NAVIGATION_LOCATIONS, bn as parseSiteId, cn as assertNever, f as EVENT_PRESET_VALUES, gn as parseMediaAssetId, gt as localScheduleTimePattern, kn as unsafeAsDetectedMimeType, mn as parseEditorSessionGeneration, n as authoredValuesEqual, p as ORDINARY_EVENT_PRESET_VALUES, u as resolveSiteVerticalBookingConfig, wn as unsafeAsBookingRequirementId, yt as parseUtcIsoDateTimeString, zn as unsafeAsPositiveByteCount } from "./src-LhtqTjH7.mjs";
+import { $n as ok, An as unsafeAsEntitlementId, B as parsePublicContactDetails, Bn as unsafeAsPositiveSeconds, Dn as unsafeAsDeclaredMimeType, Et as validateBookingPaymentOptionKinds, Fn as unsafeAsMediaAssetId, Gn as unsafeAsSiteId, Hn as unsafeAsProductId, Jn as unsafeAsStorageBucketName, K as locationValueSchema, Kn as unsafeAsSiteScopedStoragePath, Ln as unsafeAsOriginalFilename, N as parseFooterCompositionV1, P as footerNavigationLayouts, Pn as unsafeAsFileChecksumSha256, Q as isPresent, Qn as err, Qt as mapReadonlyNonEmptyArray, R as isCanonicalRichTextDoc, Tn as unsafeAsBookingSessionId, Tt as parseBookingTimeZone, Un as unsafeAsSafeDownloadFilename, V as parseWeeklyOpeningHours, W as stableJsonStringify, Wn as unsafeAsSiteFontId, Xn as unsafeAsUploadSessionId, Xt as fromArray, Yn as unsafeAsStoragePath, Zn as unsafeAsUserId, Zt as mapNonEmptyArray, a as NAVIGATION_LOCATIONS, bn as parseSiteId, cn as assertNever, f as EVENT_PRESET_VALUES, gn as parseMediaAssetId, gt as localScheduleTimePattern, kn as unsafeAsDetectedMimeType, mn as parseEditorSessionGeneration, n as authoredValuesEqual, p as ORDINARY_EVENT_PRESET_VALUES, u as resolveSiteVerticalBookingConfig, wn as unsafeAsBookingRequirementId, yt as parseUtcIsoDateTimeString, zn as unsafeAsPositiveByteCount } from "./src-DsR6-gBQ.mjs";
 import "node:module";
 import { z } from "zod";
 
@@ -771,8 +771,8 @@ function paletteColorsFromEntries(entries) {
 				}
 			};
 		}
-		const hex = normalizePaletteHex(entry.hex);
-		if (!hex) {
+		const hex$1 = normalizePaletteHex(entry.hex);
+		if (!hex$1) {
 			return {
 				ok: false,
 				error: {
@@ -782,7 +782,7 @@ function paletteColorsFromEntries(entries) {
 				}
 			};
 		}
-		values[role] = hex;
+		values[role] = hex$1;
 	}
 	const missing = PALETTE_TOKEN_NAMES.filter((role) => values[role] === undefined);
 	if (missing.length > 0) {
@@ -869,8 +869,8 @@ const clamp01$2 = (x) => Math.max(0, Math.min(1, x));
 const mod = (a, n) => (a % n + n) % n;
 const deg = (x) => mod(x, 360);
 const mix$1 = (a, b, t) => a + (b - a) * clamp01$2(t);
-function hexToRgb(hex) {
-	const h = hex.replace(/^#/, "");
+function hexToRgb(hex$1) {
+	const h = hex$1.replace(/^#/, "");
 	const m = h.length === 3 ? h.split("").map((c) => c + c).join("") : h;
 	if (m.length !== 6) throw new Error("Bad hex");
 	const int = parseInt(m, 16);
@@ -1015,8 +1015,8 @@ function oklchToHexGamut(L, C, h) {
 	const { r, g, b: bb } = oklabToSrgb(L, a, b);
 	return rgbToHex(r, g, bb);
 }
-function featuresFromHex(hex) {
-	const { r, g, b } = hexToRgb(hex);
+function featuresFromHex(hex$1) {
+	const { r, g, b } = hexToRgb(hex$1);
 	const { h, s, l } = rgbToHsl(r, g, b);
 	const { L, a, b: b2 } = srgbToOklab(r, g, b);
 	const { L: okL, C: okC, h: okH } = oklabToOklch(L, a, b2);
@@ -1037,7 +1037,7 @@ function featuresFromHex(hex) {
 		okL,
 		okC,
 		okH,
-		hex
+		hex: hex$1
 	};
 }
 function hueRotate(h, degrees) {
@@ -1130,19 +1130,19 @@ function preparePaletteColourIndex(palette) {
 	return Object.freeze(Object.fromEntries(colours.flatMap(colourIndexEntry)));
 }
 /** An unused unsupported colour must not turn preparation into an eager validation failure. */
-function colourIndexEntry(hex) {
+function colourIndexEntry(hex$1) {
 	try {
-		return [[hex, colourLuminance(hex)]];
+		return [[hex$1, colourLuminance(hex$1)]];
 	} catch {
 		return [];
 	}
 }
-function colourLuminance(hex) {
-	const { r, g, b } = hexToRgb(hex);
+function colourLuminance(hex$1) {
+	const { r, g, b } = hexToRgb(hex$1);
 	return relativeLuminance(r, g, b);
 }
-function indexedLuminance(hex, index) {
-	return (index && Object.prototype.hasOwnProperty.call(index, hex) ? index[hex] : undefined) ?? colourLuminance(hex);
+function indexedLuminance(hex$1, index) {
+	return (index && Object.prototype.hasOwnProperty.call(index, hex$1) ? index[hex$1] : undefined) ?? colourLuminance(hex$1);
 }
 /**
 * A closed luminance range with `lo <= hi`. The private field means only
@@ -1165,12 +1165,12 @@ function luminanceInterval(lo, hi = lo) {
 	return new Interval(lo, hi);
 }
 /** The relative luminance of a hex colour, read from the prepared index when given. */
-function hexLuminance(hex, index) {
-	return toLuminance(indexedLuminance(hex, index));
+function hexLuminance(hex$1, index) {
+	return toLuminance(indexedLuminance(hex$1, index));
 }
 /** The paint of a solid hex ground: a single point. */
-function solidPaint(hex, index) {
-	const y = hexLuminance(hex, index);
+function solidPaint(hex$1, index) {
+	const y = hexLuminance(hex$1, index);
 	return new Interval(y, y);
 }
 function luminanceRatio(a, b) {
@@ -1272,8 +1272,8 @@ function compositeHex$1(topHex, alpha, bottomHex) {
 function worstCaseScrimContrast(input) {
 	const overWhite = compositeHex$1(input.scrimHex, input.alpha, WHITE);
 	const overBlack = compositeHex$1(input.scrimHex, input.alpha, BLACK);
-	const luminance = (hex) => {
-		const { r, g, b } = hexToRgb(hex);
+	const luminance = (hex$1) => {
+		const { r, g, b } = hexToRgb(hex$1);
 		return relativeLuminance(r, g, b);
 	};
 	const foreground = luminance(input.foregroundHex);
@@ -1303,9 +1303,9 @@ function gradientScrimSamples(gradient, alpha, palette) {
 		alpha: alpha * (stop[4] === undefined ? 1 : Number(stop[4]))
 	}));
 	const tokens = [...gradient.matchAll(/var\(--tb-([\w-]+)\)/g)].flatMap((stop) => {
-		const hex = stop[1] ? resolveConcreteColorHex(stop[1], palette) : null;
-		return hex ? [{
-			hex,
+		const hex$1 = stop[1] ? resolveConcreteColorHex(stop[1], palette) : null;
+		return hex$1 ? [{
+			hex: hex$1,
 			alpha
 		}] : [];
 	});
@@ -1421,7 +1421,7 @@ function generateShades(hexColor, name) {
 
 //#endregion
 //#region ../theme-core/src/palette/neutralScale.ts
-function generateNeutralScale({ background, steps = 11, warm = false }) {
+function generateNeutralScale({ background, steps: steps$1 = 11, warm = false }) {
 	const isDark = background === "#000000" || background.startsWith("#0") || background.startsWith("#1");
 	const shadeNames = [
 		50,
@@ -1436,17 +1436,17 @@ function generateNeutralScale({ background, steps = 11, warm = false }) {
 		900,
 		950
 	];
-	const count = Math.min(steps, shadeNames.length);
+	const count = Math.min(steps$1, 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$2(.06, .92, t) : mix$2(.98, .1, t);
-		const hex = oklchToHexGamut(tone, .02, warm ? 85 : 250);
+		const hex$1 = oklchToHexGamut(tone, .02, warm ? 85 : 250);
 		const name = `neutral-${shadeName}`;
 		scale$1.push({
 			name,
-			hex
+			hex: hex$1
 		});
 	}
 	return scale$1;
@@ -1488,9 +1488,9 @@ function colorsToMap$1(palette) {
 	}
 	return map;
 }
-function isBackgroundDark(hex) {
+function isBackgroundDark(hex$1) {
 	try {
-		return featuresFromHex(hex).Y < .5;
+		return featuresFromHex(hex$1).Y < .5;
 	} catch {
 		return false;
 	}
@@ -1537,10 +1537,10 @@ function expandBasePalette(palette) {
 	neutral$1.forEach((n) => {
 		expanded[n.name] = n.hex;
 	});
-	for (const [name, hex] of Object.entries(base)) {
+	for (const [name, hex$1] of Object.entries(base)) {
 		if (nonShadeablePaletteRoleNames.has(name)) continue;
-		if (hex) {
-			const shades = generateShades(hex, name);
+		if (hex$1) {
+			const shades = generateShades(hex$1, name);
 			shades.forEach((shade) => {
 				expanded[shade.name] = shade.hex;
 			});
@@ -1554,11 +1554,11 @@ function expandBasePalette(palette) {
 	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;
+	for (const [token, hex$1] of Object.entries({ ...expanded })) {
+		if (!hex$1 || !isOnColorBackgroundCandidateToken(token)) continue;
 		const onToken = onColorTokenName(token);
 		if (expanded[onToken]) continue;
-		expanded[onToken] = getTextColorForBackground(hex);
+		expanded[onToken] = getTextColorForBackground(hex$1);
 	}
 	return expanded;
 }
@@ -1589,7 +1589,7 @@ function firstContrastBlend$1(from, to, ground, threshold) {
 	return Array.from({ length: 101 }, (_, index) => {
 		const amount = index / 100;
 		return rgbToHex(mix$1(start.r, end.r, amount), mix$1(start.g, end.g, amount), mix$1(start.b, end.b, amount));
-	}).find((hex) => contrastRatio(hex, ground) >= threshold) ?? to;
+	}).find((hex$1) => contrastRatio(hex$1, ground) >= threshold) ?? to;
 }
 /** `markSource` names the colour surface marks are derived from when a style marks in its brand rather than its accent. */
 function arrangementPaletteTokens(base, options) {
@@ -1600,100 +1600,6 @@ function arrangementPaletteTokens(base, options) {
 	};
 }
 
-//#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",
-	muted: "--rb-surface-muted-color",
-	line: "--rb-surface-line-color",
-	mark: "--rb-surface-mark-color"
-};
-const DEFAULT_SURFACE_TEXT_COLOR = "rgb(var(--tb-text, 17 24 39))";
-const DEFAULT_SURFACE_LINK_COLOR = "rgb(var(--tb-primary, var(--tb-text, 17 24 39)))";
-const DEFAULT_SURFACE_SUPPORTING_COLOR = "rgb(var(--tb-mutedText, 100 116 139))";
-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,
-	muted: DEFAULT_SURFACE_SUPPORTING_COLOR
-};
-function requireSurfaceColorValue(role, value) {
-	const normalized = value.trim();
-	if (normalized.length === 0) {
-		throw new RangeError(`Surface foreground ${role} must be a non-empty CSS color.`);
-	}
-	return normalized;
-}
-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,
-		linkHover: input.linkHover === undefined ? link : requireSurfaceColorValue("linkHover", input.linkHover),
-		muted: input.muted === undefined ? text : requireSurfaceColorValue("muted", input.muted),
-		supporting: input.supporting === undefined ? text : requireSurfaceColorValue("supporting", input.supporting)
-	};
-}
-function surfaceForegroundValue(role, outsideProviderFallback = DEFAULT_ROLE_FALLBACKS[role]) {
-	const roleVariable = SURFACE_FOREGROUND_CSS_VARS[role];
-	const fallback = requireSurfaceColorValue("fallback", outsideProviderFallback);
-	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) {
-	if (!Number.isFinite(opacityPercent) || opacityPercent < 0 || opacityPercent > 100) {
-		throw new RangeError("Surface foreground opacity must be between 0 and 100.");
-	}
-	return `color-mix(in srgb, ${surfaceForegroundValue(role)} ${opacityPercent}%, transparent)`;
-}
-function surfaceForegroundStyle(input) {
-	const foregrounds = completeSurfaceForegrounds(input);
-	return {
-		color: foregrounds.text,
-		[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.linkHover]: foregrounds.linkHover,
-		[SURFACE_FOREGROUND_CSS_VARS.supporting]: foregrounds.supporting,
-		...input.muted === undefined ? {} : { [SURFACE_FOREGROUND_CSS_VARS.muted]: foregrounds.muted },
-		"--rb-surface-link-hover-decoration": hoverDecoration(input)
-	};
-}
-function surfaceForegroundDeclarations(input) {
-	return Object.entries(surfaceForegroundStyle(input)).map(([property, value]) => `${property}: ${value};`);
-}
-function surfaceForegroundInputFromResolved(foreground, color) {
-	const { roles } = foreground;
-	const value = (ink) => {
-		const token = parseThemeColorToken(ink);
-		return token ? color(token) : ink;
-	};
-	return {
-		text: value(roles.text),
-		heading: value(roles.heading),
-		link: value(roles.link),
-		linkHover: value(roles.linkHover),
-		supporting: value(roles.supporting),
-		hoverDecoration: foreground.hoverDecoration
-	};
-}
-function hoverDecoration(input) {
-	return input.hoverDecoration ?? "underline";
-}
-
 //#endregion
 //#region ../theme-core/src/tokens/tokens.ts
 const colorTokens = [
@@ -1886,6 +1792,209 @@ function cloneThemeTokens(source) {
 	return JSON.parse(JSON.stringify(source));
 }
 
+//#endregion
+//#region ../theme-core/src/tokens/resolver.ts
+/**
+* Resolves theme tokens to CSS variables
+*
+* This resolver ensures all button styles use theme tokens (not hardcoded colors)
+* so that changing the palette automatically updates all buttons.
+*/
+var TokenResolver = class {
+	constructor(theme) {
+		this.theme = theme;
+	}
+	/**
+	* Resolve a color token to a CSS variable reference wrapped in rgb()
+	*
+	* @param token - Token name (e.g., 'primary-500', 'white', 'text-900')
+	* @returns CSS rgb() function with var reference (e.g., 'rgb(var(--tb-primary-500))')
+	*
+	* Note: CSS variables are stored as RGB channels (e.g., "37 99 235") following Tailwind convention,
+	* so we must wrap them with rgb() to create a valid color value.
+	*
+	* @example
+	* resolver.getColor('primary-500') // => 'rgb(var(--tb-primary-500))'
+	* resolver.getColor('white') // => 'rgb(var(--tb-white))'
+	*/
+	getColor(token) {
+		if (!this.tokenExists(token)) {
+			console.warn(`[TokenResolver] Color token "${token}" not found in theme palette. Button may render incorrectly.`);
+		}
+		return rgbColorValue(token);
+	}
+	/**
+	* Adjust a color token's shade by a given amount
+	*
+	* @param token - Base token (e.g., 'primary-500')
+	* @param amount - Shade adjustment (+100 = darker, -100 = lighter)
+	* @returns Adjusted token name (e.g., 'primary-600')
+	*
+	* @example
+	* resolver.adjustShade('primary-500', 100) // => 'primary-600' (darker)
+	* resolver.adjustShade('primary-500', -100) // => 'primary-400' (lighter)
+	*/
+	adjustShade(token, amount) {
+		const parts = token.split("-");
+		if (parts.length < 2) {
+			const newShade$1 = Math.max(100, Math.min(900, 500 + amount));
+			return `${token}-${newShade$1}`;
+		}
+		const base = parts.slice(0, -1).join("-");
+		const shade = parseInt(parts[parts.length - 1] ?? "", 10);
+		if (isNaN(shade)) {
+			console.warn(`[TokenResolver] Cannot adjust shade for non-shade token "${token}". Returning original token.`);
+			return token;
+		}
+		const newShade = Math.max(100, Math.min(900, shade + amount));
+		return `${base}-${newShade}`;
+	}
+	/**
+	* Check if a token exists in the theme palette
+	*
+	* @param token - Token name to check
+	* @returns True if token exists in theme
+	*/
+	tokenExists(token) {
+		const commonTokens = [
+			"white",
+			"black",
+			"transparent"
+		];
+		if (commonTokens.includes(token)) {
+			return true;
+		}
+		const parts = token.split("-");
+		if (parts.length >= 2) {
+			const lastPart = parts[parts.length - 1] ?? "";
+			const shade = parseInt(lastPart, 10);
+			if (!isNaN(shade) && shade >= 100 && shade <= 900 && shade % 100 === 0) {
+				return true;
+			}
+		}
+		return true;
+	}
+};
+
+//#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$1] = tone === "dark" ? ["#ffffff", "#000000"] : ["#000000", "#ffffff"];
+	return compositeHex(tint$1, 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$1(b.r, f.r, alpha)), Math.round(mix$1(b.g, f.g, alpha)), Math.round(mix$1(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 && String(candidate$1) !== String(restingToken)) {
+		if (backdrops === null || survivesEveryBackdrop(candidate$1, palette, backdrops)) {
+			return {
+				kind: "candidate",
+				token: candidate$1,
+				decoration: "initial"
+			};
+		}
+	}
+	const resting = parseThemeColorToken(restingToken);
+	const softened = resting ? deriveForegroundHoverToken(resting) : null;
+	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 = [
@@ -1897,6 +2006,425 @@ const SURFACE_FOREGROUND_ROLES = [
 	"muted"
 ];
 
+//#endregion
+//#region ../theme-core/src/palette/family.ts
+/**
+* Only `colourFamily` makes one (the class is not exported), so a caller can't
+* swap in its own members and still hand the solver a valid family. That
+* matters because `unpaintable` relies on the members running from black to
+* white.
+*/
+var Family = class {
+	#members;
+	constructor(seed, members) {
+		this.seed = seed;
+		this.#members = Object.freeze(members);
+	}
+	/** Unique by hex, ascending luminance. Includes the exact seed, black and white. */
+	get members() {
+		return this.#members;
+	}
+};
+/** Lightness steps between black and white. */
+const FAMILY_STEPS = 512;
+const GAMUT_BISECTION_STEPS = 18;
+/** The highest chroma at or below `c` that stays inside sRGB at this lightness and hue. */
+function gamutChroma(l, c, h) {
+	if (inLinearSrgbGamut(oklchToLinearSrgb(l, c, h))) return c;
+	return Array.from({ length: GAMUT_BISECTION_STEPS }).reduce(({ lo, hi }) => {
+		const mid = (lo + hi) / 2;
+		return inLinearSrgbGamut(oklchToLinearSrgb(l, mid, h)) ? {
+			lo: mid,
+			hi
+		} : {
+			lo,
+			hi: mid
+		};
+	}, {
+		lo: 0,
+		hi: c
+	}).lo;
+}
+function oklabDistance(a, b) {
+	return Math.hypot(a.L - b.L, a.a - b.a, a.b - b.b);
+}
+function colourFamily(seedHex) {
+	if (!/^#[0-9a-f]{6}$/i.test(seedHex)) throw new Error(`Expected an opaque #rrggbb colour: ${seedHex}`);
+	const features = featuresFromHex(seedHex.toLowerCase());
+	const seed = member(seedHex.toLowerCase(), {
+		l: features.okL,
+		c: features.okC,
+		h: features.okH
+	});
+	const seedTaper = Math.max(.001, Math.sin(Math.PI * seed.sample.l));
+	const samples = Array.from({ length: FAMILY_STEPS + 1 }, (_, i) => {
+		const l = i / FAMILY_STEPS;
+		const c = gamutChroma(l, seed.sample.c * Math.min(1, Math.sin(Math.PI * l) / seedTaper), seed.sample.h);
+		return sampleMember({
+			l,
+			c,
+			h: seed.sample.h
+		});
+	});
+	const unique = new Map([seed, ...samples].map((candidate$1) => [candidate$1.hex, candidate$1]).reverse());
+	const members = [...unique.values()].sort((a, b) => a.y - b.y || (a.hex < b.hex ? -1 : a.hex > b.hex ? 1 : 0));
+	return new Family(seed, members);
+}
+function sampleMember(sample) {
+	const { r, g, b } = oklchToLinearSrgb(sample.l, sample.c, sample.h);
+	return member(rgbToHex(linearToSrgb(r), linearToSrgb(g), linearToSrgb(b)), sample);
+}
+function member(hex$1, sample) {
+	const { r, g, b } = hexToRgb(hex$1);
+	return {
+		hex: hex$1,
+		y: hexLuminance(hex$1),
+		oklab: srgbToOklab(r, g, b),
+		sample
+	};
+}
+
+//#endregion
+//#region ../theme-core/src/palette/utils/inkSolver.ts
+/**
+* How far (OKLab ΔE) a brand colour drawn as ink may be nudged along its own
+* family before it stops reading as that colour. Past this the caller uses
+* neutral or palette text instead (Will, 2026-10-14).
+*/
+const BRAND_INK_MAX_DELTA_E = .08;
+/**
+* The seed itself when it clears `paint`, otherwise the family member nearest
+* the seed (OKLab ΔE) that clears. On a light ground that is darker, on a dark
+* one lighter. A passing member further than `maxDistance` from the seed is
+* refused as `too-far`, which is distinct from `unpaintable`: the family runs
+* from black to white, so if no member clears, neither does black or white.
+*/
+function inkFrom(family, paint, ratio$1, maxDistance = BRAND_INK_MAX_DELTA_E) {
+	assertContrastRatio(ratio$1);
+	if (!Number.isFinite(maxDistance) || maxDistance < 0) {
+		throw new RangeError(`Maximum ink distance must be finite and not negative: ${maxDistance}`);
+	}
+	const seedRatio = worstContrast(family.seed.y, paint);
+	if (seedRatio >= ratio$1) return {
+		kind: "ink",
+		hex: family.seed.hex,
+		ratio: seedRatio,
+		source: "exact"
+	};
+	const nearest = family.members.reduce((best, member$1) => {
+		const achieved = worstContrast(member$1.y, paint);
+		if (achieved < ratio$1) return best;
+		const distance$1 = oklabDistance(member$1.oklab, family.seed.oklab);
+		return best === null || distance$1 < best.distance ? {
+			hex: member$1.hex,
+			distance: distance$1,
+			ratio: achieved
+		} : best;
+	}, null);
+	if (nearest === null) return {
+		kind: "unpaintable",
+		interval: paint,
+		ratio: ratio$1
+	};
+	if (nearest.distance > maxDistance) {
+		return {
+			kind: "too-far",
+			nearest: {
+				hex: nearest.hex,
+				distance: nearest.distance
+			},
+			maxDistance
+		};
+	}
+	return {
+		kind: "ink",
+		hex: nearest.hex,
+		ratio: nearest.ratio,
+		source: "family"
+	};
+}
+/**
+* Neutral text for a paint. The style's preferred neutral wins when one of its
+* pair clears (the higher-contrast one, dark on a tie); otherwise literal black
+* or white by `maxContrastBlackOrWhite`; otherwise `unpaintable`.
+*/
+function neutralInk(paint, ratio$1, preferred) {
+	assertContrastRatio(ratio$1);
+	if (preferred) {
+		const dark = worstContrast(hexLuminance(preferred.dark), paint);
+		const light = worstContrast(hexLuminance(preferred.light), paint);
+		const [hex$1, achieved] = dark >= light ? [preferred.dark, dark] : [preferred.light, light];
+		if (achieved >= ratio$1) return {
+			kind: "ink",
+			hex: hex$1,
+			ratio: achieved,
+			source: "neutral"
+		};
+	}
+	const literal = maxContrastBlackOrWhite(paint);
+	return literal.ratio >= ratio$1 ? {
+		kind: "ink",
+		hex: literal.ink === "black" ? "#000000" : "#ffffff",
+		ratio: literal.ratio,
+		source: "neutral"
+	} : {
+		kind: "unpaintable",
+		interval: paint,
+		ratio: ratio$1
+	};
+}
+
+//#endregion
+//#region ../theme-core/src/surfaces/surfaceInks.ts
+const SURFACE_INK_ROLES = [
+	"brand",
+	"accent",
+	"focus"
+];
+/** Lines and focus rings are graphics: WCAG non-text contrast. */
+const GRAPHIC_MIN_CONTRAST_RATIO = 3;
+const INK_SEEDS = {
+	brand: {
+		token: "primary",
+		ratio: ORDINARY_TEXT_MIN_CONTRAST_RATIO
+	},
+	accent: {
+		token: "accent",
+		ratio: ORDINARY_TEXT_MIN_CONTRAST_RATIO
+	},
+	focus: {
+		token: "primary",
+		ratio: GRAPHIC_MIN_CONTRAST_RATIO
+	}
+};
+/**
+* Solve the three inks for a measured solid paint. `textInk` is the surface's
+* own (already certified) text ink: it stands in when the owner's colour is
+* missing, or can only clear the paint by drifting too far from itself.
+* A block owner can supply an authored shade candidate for a local ink.
+*/
+function solveSurfaceInks(backdropHex, textInk, palette, candidates = {}) {
+	const paint = solidPaint(backdropHex);
+	const fallback = literalInk(resolveConcreteColorHex(textInk, palette) ?? pickBlackOrWhiteTextColor(backdropHex));
+	return {
+		brand: solveInk({
+			...INK_SEEDS.brand,
+			token: candidates.brand ?? INK_SEEDS.brand.token
+		}, paint, palette, fallback),
+		accent: solveInk({
+			...INK_SEEDS.accent,
+			token: candidates.accent ?? INK_SEEDS.accent.token
+		}, paint, palette, fallback),
+		focus: solveInk({
+			...INK_SEEDS.focus,
+			token: candidates.focus ?? INK_SEEDS.focus.token
+		}, paint, palette, fallback)
+	};
+}
+function solveInk(seed, paint, palette, fallback) {
+	const token = parseThemeColorToken(seed.token);
+	const seedHex = hexColorSchema.safeParse(resolveConcreteColorHex(seed.token, palette));
+	if (!token || !seedHex.success) return fallback;
+	const solved = inkFrom(familyOf(seedHex.data), paint, seed.ratio);
+	switch (solved.kind) {
+		case "ink": return solved.source === "exact" ? token : literalInk(solved.hex);
+		case "too-far":
+		case "unpaintable": return fallback;
+	}
+}
+function literalInk(hex$1) {
+	return hexColorSchema.parse(hex$1.toLowerCase());
+}
+const FAMILY_CACHE_LIMIT = 64;
+const families = new Map();
+function familyOf(seed) {
+	const cached = families.get(seed);
+	if (cached) return cached;
+	if (families.size >= FAMILY_CACHE_LIMIT) families.clear();
+	const family = colourFamily(seed);
+	families.set(seed, family);
+	return family;
+}
+
+//#endregion
+//#region ../theme-core/src/surfaces/resolveSurfaceForeground.ts
+const FALLBACK_TEXT_TOKENS = [
+	"text",
+	"primaryForeground",
+	"secondaryForeground",
+	"accentForeground",
+	"neutral-950",
+	"neutral-50"
+];
+const CANONICAL_EQUIVALENT_TOKEN_ORDER = [
+	"text",
+	"primaryForeground",
+	"secondaryForeground",
+	"accentForeground",
+	"onPrimary",
+	"onSecondary",
+	"onAccent",
+	"onSurface",
+	"neutral-950",
+	"neutral-50"
+];
+function resolveSurfaceForeground(background, palette, candidates = {}, options = {}) {
+	const authored = foregroundCandidates(background, candidates);
+	if ("measuredBackdrop" in options) return resolveMeasuredForeground(background?.color ?? "background", options.measuredBackdrop, authored, palette);
+	return resolveAuthoredBackground(background, palette, authored, options);
+}
+/** Legacy references may be measurable, inherited, or a trusted media treatment. */
+function resolveAuthoredBackground(background, palette, authored, options) {
+	if (background === null) {
+		return resolveDeterministicForeground("background", {
+			...authored,
+			text: authored.text ?? "text"
+		}, palette);
+	}
+	if (background.type === "color") {
+		const backgroundReference = normalizedReference(background.color);
+		if (!backgroundReference || backgroundReference === "transparent") {
+			return { kind: "inherits" };
+		}
+		return resolveDeterministicForeground(backgroundReference, authored, palette, options.compositeBase);
+	}
+	return resolveTrustedTreatmentForeground(authored, palette);
+}
+function foregroundCandidates(background, overrides) {
+	return {
+		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) {
+		return resolveTrustedTreatmentForeground(candidates, palette);
+	}
+	return resolveMeasuredForeground(backgroundReference, backgroundHex, candidates, palette);
+}
+function resolveMeasuredForeground(backgroundReference, backgroundHex, candidates, palette) {
+	const backgroundToken$1 = paletteToken(backgroundReference);
+	const derivedOnToken = backgroundToken$1 ? onColorTokenName(backgroundToken$1) : null;
+	const text = firstSafeToken([
+		candidates.text,
+		derivedOnToken,
+		...FALLBACK_TEXT_TOKENS
+	], backgroundHex, palette, derivedOnToken ? [derivedOnToken] : []) ?? pickBlackOrWhiteTextColor(backgroundHex);
+	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,
+		inks: solveSurfaceInks(backgroundHex, text, palette)
+	}, candidates.linkHover, palette);
+}
+function resolveTrustedTreatmentForeground(candidates, palette) {
+	const text = canonicalToken(candidates.text, palette);
+	if (!text) return { kind: "unmeasured-paint" };
+	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: {
+			...roles,
+			linkHover: hover.token,
+			muted: provenance.kind === "measured" ? deriveSurfaceMutedColor(provenance.backdropHex, resolveConcreteColorHex(roles.text, palette) ?? provenance.backdropHex) : roles.text
+		},
+		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);
+}
+/**
+* The one rule for what a resolved foreground publishes for the solved inks.
+* Only a measured paint under a publishing runtime publishes inks; any other
+* paint it owns resets them, and a paint it only inherits publishes nothing.
+*/
+function surfaceInkPublication(foreground, policy) {
+	switch (foreground.kind) {
+		case "inherits": return { kind: "none" };
+		case "unmeasured-paint": return { kind: "reset" };
+		case "known": return foreground.provenance.kind === "measured" && policy === "publish" ? {
+			kind: "solved",
+			inks: foreground.provenance.inks
+		} : { kind: "reset" };
+	}
+}
+/** Keep a candidate only when it meets ordinary-text contrast on the ground. */
+function safeTokenOr(candidate$1, fallback, backgroundHex, palette) {
+	return firstSafeToken([candidate$1], backgroundHex, palette) ?? fallback;
+}
+function firstSafeToken(candidates, backgroundHex, palette, preferredEquivalentTokens = []) {
+	const seen = new Set();
+	for (const candidate$1 of candidates) {
+		const token = canonicalToken(candidate$1, palette, preferredEquivalentTokens);
+		if (!token || seen.has(token)) continue;
+		seen.add(token);
+		const foregroundHex = resolveConcreteColorHex(token, palette);
+		if (foregroundHex && contrastRatio(backgroundHex, foregroundHex) >= ORDINARY_TEXT_MIN_CONTRAST_RATIO) {
+			return token;
+		}
+	}
+	return null;
+}
+function canonicalToken(reference, palette, preferredEquivalentTokens = []) {
+	const normalized = normalizedReference(reference);
+	if (!normalized || normalized === "transparent") return null;
+	const direct = parseThemeColorToken(normalized);
+	if (direct && resolveConcreteColorHex(direct, palette)) return direct;
+	const referenceHex = resolveConcreteColorHex(normalized, palette);
+	if (!referenceHex) return null;
+	const equivalent = [
+		...preferredEquivalentTokens,
+		...CANONICAL_EQUIVALENT_TOKEN_ORDER,
+		...Object.keys(palette).sort()
+	].find((token) => {
+		const parsed = parseThemeColorToken(token);
+		return parsed !== null && resolveConcreteColorHex(parsed, palette)?.toLowerCase() === referenceHex.toLowerCase();
+	});
+	return equivalent ? parseThemeColorToken(equivalent) : null;
+}
+function paletteToken(reference) {
+	const parts = parseColorTokenParts(reference);
+	return parts.kind === "token" && parts.opacityPercent === null ? parts.token : null;
+}
+function normalizedReference(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim();
+	return normalized.length > 0 ? normalized : null;
+}
+
 //#endregion
 //#region ../theme-core/src/surfaces/logoVariant.ts
 /** Concrete hex behind a plain, opaque palette token, or null otherwise. */
@@ -1914,9 +2442,9 @@ function opaquePaletteHexForToken(expandedPalette, token) {
 * a guess.
 */
 function surfaceToneFromForegroundToken(expandedPalette, foregroundToken) {
-	const hex = opaquePaletteHexForToken(expandedPalette, foregroundToken);
-	if (!hex) return "unknown";
-	return featuresFromHex(hex).Y >= .5 ? "dark" : "light";
+	const hex$1 = opaquePaletteHexForToken(expandedPalette, foregroundToken);
+	if (!hex$1) return "unknown";
+	return featuresFromHex(hex$1).Y >= .5 ? "dark" : "light";
 }
 /**
 * The logo to draw on a surface of the given tone. A missing variant falls
@@ -3220,14 +3748,14 @@ function resolveSolid(input, backgroundToken$1, edge) {
 function resolveSolidInk(input, backgroundToken$1, backgroundHex) {
 	const foregroundToken = unsafeAsOpaqueButtonColourToken(solidForegroundToken(backgroundToken$1));
 	const candidate$1 = input.palette[foregroundToken];
-	const contrast = typeof candidate$1 === "string" ? validateButtonTextContrast({
+	const contrast$1 = typeof candidate$1 === "string" ? validateButtonTextContrast({
 		...input,
 		background: backgroundToken$1,
 		backgroundHex,
 		foreground: foregroundToken,
 		foregroundHex: candidate$1
 	}) : null;
-	if (contrast?.ok === true && typeof candidate$1 === "string") return {
+	if (contrast$1?.ok === true && typeof candidate$1 === "string") return {
 		foregroundHex: candidate$1,
 		colour: {
 			kind: "solid",
@@ -3287,14 +3815,14 @@ function resolveGradient(input, treatment) {
 		for (let sample = 0; sample <= BUTTON_CONTRAST_POLICY.gradientSamplesPerSegment; sample += 1) {
 			const position = sample / BUTTON_CONTRAST_POLICY.gradientSamplesPerSegment;
 			const sampleHex = interpolateHex(start, end, position);
-			const contrast = validateButtonTextContrast({
+			const contrast$1 = validateButtonTextContrast({
 				...input,
 				background: `${startToken}→${endToken}@${position.toFixed(2)}`,
 				backgroundHex: sampleHex,
 				foreground: treatment.foregroundToken,
 				foregroundHex: foregroundHex.hex
 			});
-			if (!contrast.ok) return contrast;
+			if (!contrast$1.ok) return contrast$1;
 			if (input.surface) {
 				const boundary = validateButtonSurfaceContrast({
 					...input,
@@ -3318,10 +3846,10 @@ function resolveGradient(input, treatment) {
 	};
 }
 function paletteHex(input, token) {
-	const hex = input.palette[token];
-	return typeof hex === "string" ? {
+	const hex$1 = input.palette[token];
+	return typeof hex$1 === "string" ? {
 		ok: true,
-		hex
+		hex: hex$1
 	} : {
 		ok: false,
 		error: {
@@ -3418,11 +3946,11 @@ function deriveKnownBackground(input, palette, fallbackToken) {
 	};
 }
 function resolveKnownSurfaceColour(value, palette, underlayReference) {
-	const hex = resolveOpaqueSurfaceHex(value, palette, underlayReference);
-	if (!hex) return resolveKnownColour(value, palette);
+	const hex$1 = resolveOpaqueSurfaceHex(value, palette, underlayReference);
+	if (!hex$1) return resolveKnownColour(value, palette);
 	const reference = parseThemeColorReference(value, { palette });
 	return {
-		hex,
+		hex: hex$1,
 		css: resolveThemeColorReferenceValue(value, { palette }),
 		source: reference.kind === "literal-css" ? "literal-css" : "palette-token"
 	};
@@ -3706,10 +4234,10 @@ function resolveKnownColour(value, palette) {
 	if (reference.kind !== "literal-css") {
 		const token = String(reference.token);
 		const paletteHex$1 = palette[token];
-		const hex$1 = paletteHex$1 ? normalizeOpaqueHex(paletteHex$1) : null;
-		if (hex$1) {
+		const hex$2 = paletteHex$1 ? normalizeOpaqueHex(paletteHex$1) : null;
+		if (hex$2) {
 			return {
-				hex: hex$1,
+				hex: hex$2,
 				css: resolveThemeColorReferenceValue(value, { palette }),
 				source: "palette-token"
 			};
@@ -3721,9 +4249,9 @@ function resolveKnownColour(value, palette) {
 			source: "literal-css"
 		} : null;
 	}
-	const hex = normalizeOpaqueCssColour(reference.value);
-	return hex ? {
-		hex,
+	const hex$1 = normalizeOpaqueCssColour(reference.value);
+	return hex$1 ? {
+		hex: hex$1,
 		css: reference.value,
 		source: "literal-css"
 	} : null;
@@ -3743,8 +4271,8 @@ const NAMED_OPAQUE_COLOURS = {
 };
 function normalizeOpaqueCssColour(value) {
 	const trimmed = value.trim();
-	const hex = normalizeOpaqueHex(trimmed);
-	if (hex) return hex;
+	const hex$1 = normalizeOpaqueHex(trimmed);
+	if (hex$1) return hex$1;
 	const named = NAMED_OPAQUE_COLOURS[trimmed.toLowerCase()];
 	return named ?? normalizeOpaqueRgb(trimmed) ?? normalizeOpaqueOklch(trimmed);
 }
@@ -3803,7 +4331,8 @@ function opaqueSurfaceContextFromTheme(theme) {
 		palette,
 		colourIndex: preparePaletteColourIndex(palette),
 		buttonSystem: theme.buttons,
-		linkHoverToken: theme.typography.proseLinkStyle?.hoverColorToken
+		linkHoverToken: theme.typography.proseLinkStyle?.hoverColorToken,
+		solvedInks: "publish"
 	};
 }
 /**
@@ -3826,6 +4355,7 @@ function opaqueSurfaceDeclarations(surface$1, arrangement = false) {
 			...arrangement ? { muted: colorValue(foreground.muted) } : {},
 			hoverDecoration: surface$1.hoverDecoration
 		}),
+		...surfaceInkDeclarations(surface$1.inks),
 		...arrangement && surface$1.decorations !== undefined ? [`${SURFACE_FOREGROUND_CSS_VARS.line}: ${surface$1.decorations.line};`, `${SURFACE_FOREGROUND_CSS_VARS.mark}: ${surface$1.decorations.mark};`] : [],
 		...Object.entries(surface$1.buttonContext.styles).map(([property, value]) => `${property}: ${value};`)
 	];
@@ -3839,6 +4369,7 @@ function inheritedSurfaceDeclarations(arrangement) {
 	return [
 		"color",
 		...Object.entries(SURFACE_FOREGROUND_CSS_VARS).filter(([role]) => arrangement || role !== "line" && role !== "mark" && role !== "muted").map(([, variable]) => variable),
+		...Object.values(SURFACE_INK_CSS_VARS),
 		"--rb-surface-link-hover-decoration",
 		...Object.keys(contextualButtonSurfaceResetStyles())
 	].map((property) => `${property}: inherit;`);
@@ -4063,8 +4594,8 @@ const mapDrawingTreatments = {
 function mapDrawingTreatmentFor(skin) {
 	return (skin === undefined ? undefined : mapDrawingTreatments[skin]) ?? defaultMapDrawingTreatment;
 }
-const toLab = (hex) => {
-	const { r, g, b } = hexToRgb(hex);
+const toLab = (hex$1) => {
+	const { r, g, b } = hexToRgb(hex$1);
 	return srgbToOklab(r, g, b);
 };
 const toHex = ({ L, a, b }) => {
@@ -4084,14 +4615,14 @@ function pole(ground, L) {
 }
 /** The first blend from `from` toward `to` that reaches the contrast floor against every backdrop. */
 function firstContrastBlend(from, to, backdrops, floor) {
-	const steps = Array.from({ length: 41 }, (_, index) => toHex(blend(from, to, index / 40)));
-	return steps.find((hex) => backdrops.every((backdrop) => contrastRatio(hex, backdrop) >= floor)) ?? toHex(to);
+	const steps$1 = Array.from({ length: 41 }, (_, index) => toHex(blend(from, to, index / 40)));
+	return steps$1.find((hex$1) => backdrops.every((backdrop) => contrastRatio(hex$1, backdrop) >= floor)) ?? toHex(to);
 }
 /** A tint must stand apart from what it is drawn on (a brand river on a brand band would vanish); else a step toward the ink. */
 function tint(base, spec, palette, ink) {
 	const candidates = spec.roles.flatMap((role) => {
-		const hex = resolveConcreteColorHex(role, palette);
-		return hex ? [blend(base, toLab(hex), spec.amount)] : [];
+		const hex$1 = resolveConcreteColorHex(role, palette);
+		return hex$1 ? [blend(base, toLab(hex$1), spec.amount)] : [];
 	});
 	return candidates.find((candidate$1) => distance(candidate$1, base) >= .025) ?? blend(base, ink, Math.max(spec.amount * .6, .06));
 }
@@ -4116,15 +4647,15 @@ function resolveMapDrawingColours(input) {
 		toHex(building)
 	];
 	const pinRoles = t.pin.flatMap((role) => {
-		const hex = resolveConcreteColorHex(role, palette);
-		return hex ? [hex] : [];
+		const hex$1 = resolveConcreteColorHex(role, palette);
+		return hex$1 ? [hex$1] : [];
 	});
-	const pin = [...pinRoles, input.ink].find((hex) => pinBackdrops.every((backdrop) => contrastRatio(hex, backdrop) >= 3)) ?? firstContrastBlend(toLab(pinRoles[0] ?? input.ink), ink, pinBackdrops, 3);
+	const pin = [...pinRoles, input.ink].find((hex$1) => pinBackdrops.every((backdrop) => contrastRatio(hex$1, backdrop) >= 3)) ?? firstContrastBlend(toLab(pinRoles[0] ?? input.ink), ink, pinBackdrops, 3);
 	const pinEdge = [
 		toHex(light),
 		toHex(dark),
 		landHex
-	].reduce((best, hex) => contrastRatio(hex, pin) > contrastRatio(best, pin) ? hex : best);
+	].reduce((best, hex$1) => contrastRatio(hex$1, pin) > contrastRatio(best, pin) ? hex$1 : best);
 	return {
 		land: landHex,
 		water: toHex(tint(land, t.water, palette, ink)),
@@ -4330,369 +4861,138 @@ function mergeStyles(...styles) {
 }
 
 //#endregion
-//#region ../theme-core/src/tokens/resolver.ts
-/**
-* Resolves theme tokens to CSS variables
-*
-* This resolver ensures all button styles use theme tokens (not hardcoded colors)
-* so that changing the palette automatically updates all buttons.
-*/
-var TokenResolver = class {
-	constructor(theme) {
-		this.theme = theme;
-	}
-	/**
-	* Resolve a color token to a CSS variable reference wrapped in rgb()
-	*
-	* @param token - Token name (e.g., 'primary-500', 'white', 'text-900')
-	* @returns CSS rgb() function with var reference (e.g., 'rgb(var(--tb-primary-500))')
-	*
-	* Note: CSS variables are stored as RGB channels (e.g., "37 99 235") following Tailwind convention,
-	* so we must wrap them with rgb() to create a valid color value.
-	*
-	* @example
-	* resolver.getColor('primary-500') // => 'rgb(var(--tb-primary-500))'
-	* resolver.getColor('white') // => 'rgb(var(--tb-white))'
-	*/
-	getColor(token) {
-		if (!this.tokenExists(token)) {
-			console.warn(`[TokenResolver] Color token "${token}" not found in theme palette. Button may render incorrectly.`);
-		}
-		return rgbColorValue(token);
+//#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",
+	muted: "--rb-surface-muted-color",
+	line: "--rb-surface-line-color",
+	mark: "--rb-surface-mark-color"
+};
+const DEFAULT_SURFACE_TEXT_COLOR = "rgb(var(--tb-text, 17 24 39))";
+const DEFAULT_SURFACE_LINK_COLOR = "rgb(var(--tb-primary, var(--tb-text, 17 24 39)))";
+const DEFAULT_SURFACE_SUPPORTING_COLOR = "rgb(var(--tb-mutedText, 100 116 139))";
+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,
+	muted: DEFAULT_SURFACE_SUPPORTING_COLOR
+};
+function requireSurfaceColorValue(role, value) {
+	const normalized = value.trim();
+	if (normalized.length === 0) {
+		throw new RangeError(`Surface foreground ${role} must be a non-empty CSS color.`);
 	}
-	/**
-	* Adjust a color token's shade by a given amount
-	*
-	* @param token - Base token (e.g., 'primary-500')
-	* @param amount - Shade adjustment (+100 = darker, -100 = lighter)
-	* @returns Adjusted token name (e.g., 'primary-600')
-	*
-	* @example
-	* resolver.adjustShade('primary-500', 100) // => 'primary-600' (darker)
-	* resolver.adjustShade('primary-500', -100) // => 'primary-400' (lighter)
-	*/
-	adjustShade(token, amount) {
-		const parts = token.split("-");
-		if (parts.length < 2) {
-			const newShade$1 = Math.max(100, Math.min(900, 500 + amount));
-			return `${token}-${newShade$1}`;
-		}
-		const base = parts.slice(0, -1).join("-");
-		const shade = parseInt(parts[parts.length - 1] ?? "", 10);
-		if (isNaN(shade)) {
-			console.warn(`[TokenResolver] Cannot adjust shade for non-shade token "${token}". Returning original token.`);
-			return token;
-		}
-		const newShade = Math.max(100, Math.min(900, shade + amount));
-		return `${base}-${newShade}`;
+	return normalized;
+}
+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,
+		linkHover: input.linkHover === undefined ? link : requireSurfaceColorValue("linkHover", input.linkHover),
+		muted: input.muted === undefined ? text : requireSurfaceColorValue("muted", input.muted),
+		supporting: input.supporting === undefined ? text : requireSurfaceColorValue("supporting", input.supporting)
+	};
+}
+function surfaceForegroundValue(role, outsideProviderFallback = DEFAULT_ROLE_FALLBACKS[role]) {
+	const roleVariable = SURFACE_FOREGROUND_CSS_VARS[role];
+	const fallback = requireSurfaceColorValue("fallback", outsideProviderFallback);
+	if (role === "text") {
+		return `var(${roleVariable}, ${fallback})`;
 	}
-	/**
-	* Check if a token exists in the theme palette
-	*
-	* @param token - Token name to check
-	* @returns True if token exists in theme
-	*/
-	tokenExists(token) {
-		const commonTokens = [
-			"white",
-			"black",
-			"transparent"
-		];
-		if (commonTokens.includes(token)) {
-			return true;
-		}
-		const parts = token.split("-");
-		if (parts.length >= 2) {
-			const lastPart = parts[parts.length - 1] ?? "";
-			const shade = parseInt(lastPart, 10);
-			if (!isNaN(shade) && shade >= 100 && shade <= 900 && shade % 100 === 0) {
-				return true;
-			}
-		}
-		return true;
+	if (role === "linkHover") {
+		return `var(${roleVariable}, ${surfaceForegroundValue("link", fallback)})`;
 	}
+	return `var(${roleVariable}, var(${SURFACE_FOREGROUND_CSS_VARS.text}, ${fallback}))`;
+}
+/** The three solved inks, published beside the foreground roles by the same surfaces. */
+const SURFACE_INK_CSS_VARS = {
+	brand: "--rb-surface-brand-color",
+	accent: "--rb-surface-accent-color",
+	focus: "--rb-surface-focus-color"
 };
-
-//#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.
+* Read a solved ink, falling back straight to the declaration's own previous
+* expression. Unlike `surfaceForegroundValue` this never falls through to
+* `--rb-surface-text-color`: where no ink is published (bridge pages, unmeasured
+* paints) brand text must keep its brand colour, not turn into the text ink.
 */
-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}`);
+function surfaceInkValue(role, previousExpression) {
+	return `var(${SURFACE_INK_CSS_VARS[role]}, ${requireSurfaceColorValue("fallback", previousExpression)})`;
 }
 /**
-* 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.
+* The declarations for a surface's ink publication. An exact ink is a token
+* reference (`rgb(var(--tb-primary))`), so a site's own token value wins; a
+* nudged or replaced ink is a literal colour.
 */
-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$1] = tone === "dark" ? ["#ffffff", "#000000"] : ["#000000", "#ffffff"];
-	return compositeHex(tint$1, over, CONTRAST_GLASS_ALPHA);
+function surfaceInkStyle(publication) {
+	switch (publication.kind) {
+		case "none": return {};
+		case "reset": return inkVariables(() => "initial");
+		case "solved": return inkVariables((role) => {
+			const ink = publication.inks[role];
+			const token = parseThemeColorToken(ink);
+			return token ? rgbColorValue(token) : ink;
+		});
+	}
 }
-/** 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$1(b.r, f.r, alpha)), Math.round(mix$1(b.g, f.g, alpha)), Math.round(mix$1(b.b, f.b, alpha)));
+function surfaceInkDeclarations(publication) {
+	return Object.entries(surfaceInkStyle(publication)).map(([property, value]) => `${property}: ${value};`);
 }
-/**
-* 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 && String(candidate$1) !== String(restingToken)) {
-		if (backdrops === null || survivesEveryBackdrop(candidate$1, palette, backdrops)) {
-			return {
-				kind: "candidate",
-				token: candidate$1,
-				decoration: "initial"
-			};
-		}
-	}
-	const resting = parseThemeColorToken(restingToken);
-	const softened = resting ? deriveForegroundHoverToken(resting) : null;
-	if (softened && backdrops && survivesEveryBackdrop(softened, palette, backdrops)) {
-		return {
-			kind: "softened",
-			token: softened,
-			decoration: "initial"
-		};
-	}
+function inkVariables(value) {
 	return {
-		kind: "resting",
-		token: restingToken,
-		decoration: "underline"
+		[SURFACE_INK_CSS_VARS.brand]: value("brand"),
+		[SURFACE_INK_CSS_VARS.accent]: value("accent"),
+		[SURFACE_INK_CSS_VARS.focus]: value("focus")
 	};
 }
-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/resolveSurfaceForeground.ts
-const FALLBACK_TEXT_TOKENS = [
-	"text",
-	"primaryForeground",
-	"secondaryForeground",
-	"accentForeground",
-	"neutral-950",
-	"neutral-50"
-];
-const CANONICAL_EQUIVALENT_TOKEN_ORDER = [
-	"text",
-	"primaryForeground",
-	"secondaryForeground",
-	"accentForeground",
-	"onPrimary",
-	"onSecondary",
-	"onAccent",
-	"onSurface",
-	"neutral-950",
-	"neutral-50"
-];
-function resolveSurfaceForeground(background, palette, candidates = {}, options = {}) {
-	const authored = foregroundCandidates(background, candidates);
-	if ("measuredBackdrop" in options) return resolveMeasuredForeground(background?.color ?? "background", options.measuredBackdrop, authored, palette);
-	return resolveAuthoredBackground(background, palette, authored, options);
-}
-/** Legacy references may be measurable, inherited, or a trusted media treatment. */
-function resolveAuthoredBackground(background, palette, authored, options) {
-	if (background === null) {
-		return resolveDeterministicForeground("background", {
-			...authored,
-			text: authored.text ?? "text"
-		}, palette);
-	}
-	if (background.type === "color") {
-		const backgroundReference = normalizedReference(background.color);
-		if (!backgroundReference || backgroundReference === "transparent") {
-			return { kind: "unknown" };
-		}
-		return resolveDeterministicForeground(backgroundReference, authored, palette, options.compositeBase);
+function surfaceForegroundValueWithOpacity(role, opacityPercent) {
+	if (!Number.isFinite(opacityPercent) || opacityPercent < 0 || opacityPercent > 100) {
+		throw new RangeError("Surface foreground opacity must be between 0 and 100.");
 	}
-	return resolveTrustedTreatmentForeground(authored, palette);
+	return `color-mix(in srgb, ${surfaceForegroundValue(role)} ${opacityPercent}%, transparent)`;
 }
-function foregroundCandidates(background, overrides) {
+function surfaceForegroundStyle(input) {
+	const foregrounds = completeSurfaceForegrounds(input);
 	return {
-		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)
+		color: foregrounds.text,
+		[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.linkHover]: foregrounds.linkHover,
+		[SURFACE_FOREGROUND_CSS_VARS.supporting]: foregrounds.supporting,
+		...input.muted === undefined ? {} : { [SURFACE_FOREGROUND_CSS_VARS.muted]: foregrounds.muted },
+		"--rb-surface-link-hover-decoration": hoverDecoration(input)
 	};
 }
-function candidateOrBackground(candidate$1, backgroundValue) {
-	return candidate$1 ?? backgroundValue ?? null;
-}
-function resolveDeterministicForeground(backgroundReference, candidates, palette, compositeBase) {
-	const backgroundHex = resolveOpaqueSurfaceHex(backgroundReference, palette, compositeBase);
-	if (!backgroundHex) {
-		return resolveTrustedTreatmentForeground(candidates, palette);
-	}
-	return resolveMeasuredForeground(backgroundReference, backgroundHex, candidates, palette);
-}
-function resolveMeasuredForeground(backgroundReference, backgroundHex, candidates, palette) {
-	const backgroundToken$1 = paletteToken(backgroundReference);
-	const derivedOnToken = backgroundToken$1 ? onColorTokenName(backgroundToken$1) : null;
-	const text = firstSafeToken([
-		candidates.text,
-		derivedOnToken,
-		...FALLBACK_TEXT_TOKENS
-	], backgroundHex, palette, derivedOnToken ? [derivedOnToken] : []) ?? pickBlackOrWhiteTextColor(backgroundHex);
-	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 surfaceForegroundDeclarations(input) {
+	return Object.entries(surfaceForegroundStyle(input)).map(([property, value]) => `${property}: ${value};`);
 }
-function knownForeground(roles, provenance, hoverCandidate, palette) {
-	const hover = planForegroundHover({
-		restingToken: roles.link,
-		candidate: canonicalHoverToken(hoverCandidate, palette),
-		palette,
-		backdrops: provenance.kind === "measured" ? [provenance.backdropHex] : null
-	});
+function surfaceForegroundInputFromResolved(foreground, color) {
+	const { roles } = foreground;
+	const value = (ink) => {
+		const token = parseThemeColorToken(ink);
+		return token ? color(token) : ink;
+	};
 	return {
-		kind: "known",
-		provenance,
-		roles: {
-			...roles,
-			linkHover: hover.token,
-			muted: provenance.kind === "measured" ? deriveSurfaceMutedColor(provenance.backdropHex, resolveConcreteColorHex(roles.text, palette) ?? provenance.backdropHex) : roles.text
-		},
-		hoverDecoration: hover.decoration
+		text: value(roles.text),
+		heading: value(roles.heading),
+		link: value(roles.link),
+		linkHover: value(roles.linkHover),
+		supporting: value(roles.supporting),
+		hoverDecoration: foreground.hoverDecoration
 	};
 }
-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);
-}
-/** Keep a candidate only when it meets ordinary-text contrast on the ground. */
-function safeTokenOr(candidate$1, fallback, backgroundHex, palette) {
-	return firstSafeToken([candidate$1], backgroundHex, palette) ?? fallback;
-}
-function firstSafeToken(candidates, backgroundHex, palette, preferredEquivalentTokens = []) {
-	const seen = new Set();
-	for (const candidate$1 of candidates) {
-		const token = canonicalToken(candidate$1, palette, preferredEquivalentTokens);
-		if (!token || seen.has(token)) continue;
-		seen.add(token);
-		const foregroundHex = resolveConcreteColorHex(token, palette);
-		if (foregroundHex && contrastRatio(backgroundHex, foregroundHex) >= ORDINARY_TEXT_MIN_CONTRAST_RATIO) {
-			return token;
-		}
-	}
-	return null;
-}
-function canonicalToken(reference, palette, preferredEquivalentTokens = []) {
-	const normalized = normalizedReference(reference);
-	if (!normalized || normalized === "transparent") return null;
-	const direct = parseThemeColorToken(normalized);
-	if (direct && resolveConcreteColorHex(direct, palette)) return direct;
-	const referenceHex = resolveConcreteColorHex(normalized, palette);
-	if (!referenceHex) return null;
-	const equivalent = [
-		...preferredEquivalentTokens,
-		...CANONICAL_EQUIVALENT_TOKEN_ORDER,
-		...Object.keys(palette).sort()
-	].find((token) => {
-		const parsed = parseThemeColorToken(token);
-		return parsed !== null && resolveConcreteColorHex(parsed, palette)?.toLowerCase() === referenceHex.toLowerCase();
-	});
-	return equivalent ? parseThemeColorToken(equivalent) : null;
-}
-function paletteToken(reference) {
-	const parts = parseColorTokenParts(reference);
-	return parts.kind === "token" && parts.opacityPercent === null ? parts.token : null;
-}
-function normalizedReference(value) {
-	if (typeof value !== "string") return null;
-	const normalized = value.trim();
-	return normalized.length > 0 ? normalized : null;
+function hoverDecoration(input) {
+	return input.hoverDecoration ?? "underline";
 }
 
 //#endregion
@@ -4862,22 +5162,22 @@ function resolveAccessibleSurfaceRecipe(input) {
 	if (result.kind === "resolved-accessible-surface") return result;
 	const recipe = surfaceRecipes[input.surface];
 	const token = recipe.backgroundCandidates.find((candidate$1) => resolveConcreteColorHex(candidate$1, input.palette) !== null);
-	const hex = token ? resolveConcreteColorHex(token, input.palette) : null;
-	if (!token || !hex) return result;
-	const ink = pickBlackOrWhiteTextColor(hex);
+	const hex$1 = token ? resolveConcreteColorHex(token, input.palette) : null;
+	if (!token || !hex$1) return result;
+	const ink = pickBlackOrWhiteTextColor(hex$1);
 	const foreground = (role) => ({
 		kind: "safe-token",
 		role,
 		token: asAccessibleSurfaceToken(ink),
 		hex: ink,
-		contrastRatio: contrastRatio(ink, hex)
+		contrastRatio: contrastRatio(ink, hex$1)
 	});
 	return {
 		kind: "resolved-accessible-surface",
 		surface: input.surface,
 		background: {
 			token: asAccessibleSurfaceToken(token),
-			hex,
+			hex: hex$1,
 			inherited: recipe.inheritedBackground
 		},
 		heading: {
@@ -5066,12 +5366,12 @@ function surfaceResolutionFailureReason(rejectedCandidates) {
 	return rejectedCandidates.some((candidate$1) => candidate$1.kind === "foreground-candidate") ? "no-safe-foreground-candidate" : "no-background-candidate";
 }
 function missingBackgroundSurface(input) {
-	const contrast = contrastRatio(missingBackgroundTokens.foreground, missingBackgroundTokens.background);
+	const contrast$1 = contrastRatio(missingBackgroundTokens.foreground, missingBackgroundTokens.background);
 	const foreground = {
 		kind: "safe-token",
 		token: asAccessibleSurfaceToken(missingBackgroundTokens.foreground),
 		hex: missingBackgroundTokens.foreground,
-		contrastRatio: contrast
+		contrastRatio: contrast$1
 	};
 	return {
 		kind: "resolved-accessible-surface",
@@ -5146,7 +5446,8 @@ function surfaceTransportContext(context) {
 	const revision = ownSurfaceRevision(context);
 	const result = Object.freeze({
 		...revision,
-		colourIndex: context.colourIndex
+		colourIndex: context.colourIndex,
+		solvedInks: context.solvedInks
 	});
 	surfaceRevisionOwners.set(result, revision);
 	return result;
@@ -5172,7 +5473,7 @@ function resolveSurface(spec, context) {
 	return spec.kind === "section" ? resolveSectionSurface(spec.background, context) : preparedSurfaceValue(spec, context) ?? certifySurface(spec, context);
 }
 /** Own one theme revision; derive its surface decisions without copying its inputs again. */
-function prepareThemeSurfaceRevision(inputTheme, selectSurfaces = () => []) {
+function prepareThemeSurfaceRevision(inputTheme, selectSurfaces = () => [], solvedInks) {
 	const theme = structuredClone(inputTheme);
 	const snapshot = freezeOwnedThemeValue(theme);
 	const declarations = ownedThemeSnapshot(selectSurfaces(snapshot));
@@ -5184,7 +5485,8 @@ function prepareThemeSurfaceRevision(inputTheme, selectSurfaces = () => []) {
 		kind: "concrete-palette",
 		palette,
 		colourIndex: preparePaletteColourIndex(palette),
-		buttonSystem: snapshot.buttons
+		buttonSystem: snapshot.buttons,
+		solvedInks
 	});
 	registerOwnedRevisionInputs(context);
 	const preparedSurfaces = declarations.length === 0 ? undefined : surfaceIndexFromOwnedInputs(declarations, context);
@@ -5204,7 +5506,8 @@ function prepareSurfaceIndex(specs, context) {
 		linkHoverToken: context.linkHoverToken,
 		foreground: context.foreground,
 		compositeBase: context.compositeBase,
-		buttonContext: context.buttonContext
+		buttonContext: context.buttonContext,
+		solvedInks: context.solvedInks
 	});
 	return surfaceIndexFromOwnedInputs(ownedThemeSnapshot(specs), snapshot);
 }
@@ -5244,7 +5547,8 @@ function surfaceResolutionKey(spec, context) {
 		context.linkHoverToken,
 		context.foreground,
 		context.compositeBase,
-		context.buttonContext
+		context.buttonContext,
+		context.solvedInks
 	]);
 }
 function resolveSurfaceSpec(spec, context) {
@@ -5318,6 +5622,7 @@ function resolveOwnedSurface(paint, context, measuredBackdrop) {
 	const decision = {
 		kind: "owned",
 		foreground,
+		inks: ownedInkPublication(resolved, context),
 		decorations: surfaceDecorationColors(resolved, context.palette),
 		hoverDecoration: resolved.kind === "known" ? resolved.hoverDecoration : "underline",
 		buttonContext: resolveSurfaceButtons(paint, resolved, context)
@@ -5327,11 +5632,11 @@ function resolveOwnedSurface(paint, context, measuredBackdrop) {
 		paint,
 		contrast: { kind: "unmeasured" }
 	};
-	const contrast = surfaceContrast(resolved, context.palette, context.colourIndex);
-	return contrast.kind === "measured" ? {
+	const contrast$1 = surfaceContrast(resolved, context.palette, context.colourIndex);
+	return contrast$1.kind === "measured" ? {
 		...decision,
 		paint,
-		contrast
+		contrast: contrast$1
 	} : {
 		...decision,
 		paint,
@@ -5342,6 +5647,11 @@ function resolveOwnedSurface(paint, context, measuredBackdrop) {
 		}
 	};
 }
+/** A paint the element owns but that resolves as inherited (an empty token) still blocks outer inks. */
+function ownedInkPublication(resolved, context) {
+	const publication = surfaceInkPublication(resolved, context.solvedInks ?? "withhold");
+	return publication.kind === "none" ? { kind: "reset" } : publication;
+}
 /** Unprovable legacy paint retains its declared foreground instead of inventing one. */
 function ownedForegroundRoles(resolved, text, candidates) {
 	if (resolved.kind === "known") return resolved.roles;
@@ -5390,7 +5700,7 @@ function surfaceContrast(foreground, palette, colourIndex) {
 }
 /** Runtime backgrounds retain authored media, compositing and unknown foregrounds. */
 function resolveSectionSurface(background, context) {
-	const foreground = background === null ? { kind: "unknown" } : resolveSurfaceForeground(background, context.palette, {
+	const foreground = background === null ? { kind: "inherits" } : resolveSurfaceForeground(background, context.palette, {
 		linkHover: context.linkHoverToken,
 		...context.foreground
 	}, { compositeBase: context.compositeBase });
@@ -5404,6 +5714,7 @@ function resolveSectionSurface(background, context) {
 	const result = {
 		kind: "section",
 		foreground,
+		inks: surfaceInkPublication(foreground, context.solvedInks ?? "withhold"),
 		buttonStyles: resolveSurfaceButtonContext({
 			surface: surface$1,
 			palette: revision.palette,
@@ -5442,8 +5753,8 @@ function resolveTintSurface(spec, context) {
 	}, context);
 	const source = spec.source === "text" ? base.foreground.text : base.decorations?.mark;
 	const token = source ? resolveOpaqueSurfaceHex(`${source}/${spec.opacity}`, context.palette, spec.base) : null;
-	const hex = source ? resolveConcreteColorHex(source, context.palette) : null;
-	const tinted = token ?? (hex ? resolveOpaqueSurfaceHex(hexToRgba(hex, spec.opacity / 100), context.palette, spec.base) : null);
+	const hex$1 = source ? resolveConcreteColorHex(source, context.palette) : null;
+	const tinted = token ?? (hex$1 ? resolveOpaqueSurfaceHex(hexToRgba(hex$1, spec.opacity / 100), context.palette, spec.base) : null);
 	if (!tinted) throw new Error(`Cannot derive tint on ${spec.base}`);
 	const solid = resolveDeclaredSolidSurface({
 		kind: "solid",
@@ -5456,6 +5767,7 @@ function resolveTintSurface(spec, context) {
 	assertTintSamples(solid, spec.base, context.palette);
 	return {
 		...solid,
+		inks: { kind: "reset" },
 		tintBase: spec.base
 	};
 }
@@ -5479,8 +5791,8 @@ function assertTintSamples(surface$1, base, palette) {
 		if (!safe) throw new RangeError(`No checked tint gradient for ${role} on ${base}`);
 	});
 }
-function hexToRgba(hex, alpha) {
-	const { r, g, b } = hexToRgb(hex);
+function hexToRgba(hex$1, alpha) {
+	const { r, g, b } = hexToRgb(hex$1);
 	return `rgba(${r}, ${g}, ${b}, ${alpha})`;
 }
 const foregroundInputSchema = z.object({
@@ -5503,6 +5815,7 @@ const paintInputSchema = z.discriminatedUnion("kind", [
 	z.object({ kind: z.literal("transparent") })
 ]);
 const buttonInputSchema = z.object({ primary: opaqueButtonColourTokenSchema });
+const solvedInksSchema = z.enum(["publish", "withhold"]);
 const surfaceSpecSchema = z.discriminatedUnion("kind", [
 	z.object({
 		kind: z.literal("recipe"),
@@ -5539,16 +5852,21 @@ const surfaceTransportSchema = z.object({ $surface: z.object({
 		foreground: foregroundInputSchema.optional(),
 		linkHoverToken: z.string().optional(),
 		compositeBase: z.string().optional(),
-		buttonContext: buttonInputSchema.optional()
+		buttonContext: buttonInputSchema.optional(),
+		solvedInks: solvedInksSchema.optional()
 	})
 }) });
 /** Deserialised output is never evidence: parse the inputs and rerun their owner. */
 function parseResolvedSurface(value) {
-	if (isResolvedSurface(value)) return value;
-	const { spec, context } = surfaceTransportSchema.parse(value).$surface;
+	return resolveTransportedSurface(value);
+}
+function resolveTransportedSurface(value, solvedInks) {
+	if (isResolvedSurface(value) && solvedInks === undefined) return value;
+	const { spec, context } = isResolvedSurface(value) ? serializeResolvedSurface(value).$surface : surfaceTransportSchema.parse(value).$surface;
 	return resolveSurface(spec, {
 		...context,
-		buttonSystem: context.buttonSystem
+		buttonSystem: context.buttonSystem,
+		solvedInks: solvedInks ?? context.solvedInks
 	});
 }
 /** Wire only the owner inputs; parsed CSS/results are recomputed, never trusted. */
@@ -5568,7 +5886,8 @@ function certifySurface(spec, context) {
 				foreground: context.foreground,
 				linkHoverToken: context.linkHoverToken,
 				compositeBase: context.compositeBase,
-				buttonContext: context.buttonContext
+				buttonContext: context.buttonContext,
+				solvedInks: context.solvedInks
 			})
 		})
 	};
@@ -5614,7 +5933,10 @@ function serializeSurfaceTree(value) {
 	};
 	const encode = (item) => {
 		const revision = isSurfaceTreeRecord(item) ? surfaceRevisionOwners.get(item) : undefined;
-		if (revision) return { $surfaceRevision: revisionIndex(revision) };
+		if (revision) return {
+			$surfaceRevision: revisionIndex(revision),
+			solvedInks: isSurfaceTreeRecord(item) ? item.solvedInks : undefined
+		};
 		if (isResolvedSurface(item)) {
 			const input = serializeResolvedSurface(item).$surface;
 			const index = revisionIndex(item.revision);
@@ -5647,19 +5969,28 @@ const surfaceReferenceSchema = z.object({ $surface: z.object({
 		foreground: foregroundInputSchema.optional(),
 		linkHoverToken: z.string().optional(),
 		compositeBase: z.string().optional(),
-		buttonContext: buttonInputSchema.optional()
+		buttonContext: buttonInputSchema.optional(),
+		solvedInks: solvedInksSchema.optional()
 	})
 }) });
-const surfaceRevisionReferenceSchema = z.object({ $surfaceRevision: z.number().int().nonnegative() });
+const surfaceRevisionReferenceSchema = z.object({
+	$surfaceRevision: z.number().int().nonnegative(),
+	solvedInks: solvedInksSchema.optional()
+});
 /** Recreate owner results before any island's ordinary schema consumes them. */
-function parseSurfaceTree(value) {
-	if (isSurfaceTransportLeaf(value)) return value;
-	if (!isSurfaceTreeRecord(value) || !("$surfaceTransport" in value)) return mapSurfaceTreeChildren(value, parseSurfaceTree);
+function parseSurfaceTree(value, solvedInks) {
+	if (isResolvedSurface(value)) return resolveTransportedSurface(value, solvedInks);
+	const revision = isSurfaceTreeRecord(value) ? surfaceRevisionOwners.get(value) : undefined;
+	if (revision) return solvedInks === undefined ? value : surfaceTransportContext({
+		...revision,
+		solvedInks
+	});
+	if (!isSurfaceTreeRecord(value) || !("$surfaceTransport" in value)) return mapSurfaceTreeChildren(value, (item) => parseSurfaceTree(item, solvedInks));
 	const envelope = surfaceEnvelopeSchema.parse(value).$surfaceTransport;
-	const revisions = envelope.revisions.map((revision) => {
+	const revisions = envelope.revisions.map((revision$1) => {
 		const owned = ownedThemeSnapshot({
-			palette: revision.palette,
-			buttonSystem: revision.buttonSystem
+			palette: revision$1.palette,
+			buttonSystem: revision$1.buttonSystem
 		});
 		registerOwnedRevisionInputs(owned);
 		return ownSurfaceRevision(owned);
@@ -5667,18 +5998,23 @@ function parseSurfaceTree(value) {
 	const decode = (item) => {
 		if (isSurfaceTreeRecord(item) && "$surfaceRevision" in item) {
 			const reference = surfaceRevisionReferenceSchema.parse(item);
-			const revision = revisions[reference.$surfaceRevision];
-			if (!revision) throw new Error("Unknown surface revision");
-			return revision;
+			const revision$1 = revisions[reference.$surfaceRevision];
+			if (!revision$1) throw new Error("Unknown surface revision");
+			const policy = solvedInks ?? reference.solvedInks;
+			return policy === undefined ? revision$1 : surfaceTransportContext({
+				...revision$1,
+				solvedInks: policy
+			});
 		}
 		if (isSurfaceTreeRecord(item) && "$surface" in item) {
 			const request = surfaceReferenceSchema.parse(item).$surface;
-			const revision = revisions[request.revision];
-			if (!revision) throw new Error("Unknown surface revision");
+			const revision$1 = revisions[request.revision];
+			if (!revision$1) throw new Error("Unknown surface revision");
 			return resolveSurface(request.spec, {
-				...revision,
+				...revision$1,
 				...request.context,
-				buttonSystem: revision.buttonSystem
+				buttonSystem: revision$1.buttonSystem,
+				solvedInks: solvedInks ?? request.context.solvedInks
 			});
 		}
 		return mapSurfaceTreeChildren(item, decode);
@@ -5783,9 +6119,9 @@ function makeBoundaryId(previousBlockId, nextBlockId) {
 function assertNever$1(value, message = "Unhandled Theme V2 variant") {
 	throw new Error(`${message}: ${String(value)}`);
 }
-function brandNonEmptyString(value, label) {
+function brandNonEmptyString(value, label$1) {
 	if (value.length === 0) {
-		throw new Error(`${label} must be a non-empty string.`);
+		throw new Error(`${label$1} must be a non-empty string.`);
 	}
 	return value;
 }
@@ -7229,6 +7565,14 @@ const blockAppearancePresets = [
 		slotRoles: { copy: "card" },
 		styleFallback: [id$1("hero-photo-beside-text")]
 	}),
+	defineArrangementLook("hero-text-over-photo", "hero", "Text over photo", "classic", [], {
+		photoTreatment: "text-overlay",
+		whenMissing: [{
+			fact: "photo",
+			look: id$1("hero-page-head")
+		}],
+		styleFallback: [id$1("hero-photo-behind-text")]
+	}),
 	defineArrangementLook("hero-short-photo-banner", "hero", "Short photo banner", "classic", [], {
 		slotRoles: { copy: "card" },
 		styleFallback: [id$1("hero-page-head")]
@@ -11897,8 +12241,8 @@ function getRasterAssetIds(assets) {
 function getMissingAssetUsageIds(input) {
 	return input.rasterAssetIds.filter((assetId) => {
 		if (input.inFlightAssetIds.has(assetId)) return false;
-		const status = input.storedStatusByAssetId[assetId];
-		return status === undefined || status.kind === "unknown";
+		const status$1 = input.storedStatusByAssetId[assetId];
+		return status$1 === undefined || status$1.kind === "unknown";
 	});
 }
 function markAssetUsageChecking(statusByAssetId, assetIds) {
@@ -13953,12 +14297,31 @@ function parseCanonicalRuntimeBackground(content) {
 	if (!background) return { kind: "none" };
 	const parsed = runtimeBoxBackgroundSchema.safeParse(background);
 	if (!parsed.success) return { kind: "none" };
-	return parsed.data.contentOwner === pageDesignEditorBackgroundOverrideOwner ? {
+	const painted = applyLookPhotoTreatment(content, parsed.data);
+	return painted.contentOwner === pageDesignEditorBackgroundOverrideOwner ? {
 		kind: "page-design-override",
-		background: parsed.data
+		background: painted
 	} : {
 		kind: "block-authored",
-		background: parsed.data
+		background: painted
+	};
+}
+/** The Look owns shading and ink together; authored image/crop stay intact. */
+function applyLookPhotoTreatment(content, background) {
+	const look$1 = readRecord(readRecord(content._effectiveLook)?.look);
+	const structure = readRecord(look$1?.structure);
+	if (background.type !== "image" || structure?.photoTreatment !== "text-overlay") return background;
+	return {
+		...background,
+		overlay: {
+			type: "gradient",
+			opacity: 1,
+			gradient: "var(--rb-opening-photo-shade, linear-gradient(transparent, transparent)), linear-gradient(to top, rgba(0,0,0,0.88) 0%, rgba(0,0,0,0.76) 25%, rgba(0,0,0,0.4) 46%, transparent 72%)"
+		},
+		textColor: "neutral-50",
+		headingColor: "neutral-50",
+		linkColor: "neutral-50",
+		supportingColor: "neutral-50"
 	};
 }
 function resolveSectionBackground(source, lookDefault, rhythm, arrangementHeroPhoto) {
@@ -14015,8 +14378,15 @@ function resolveSectionForeground(background, palette) {
 * `resolveSectionBackground` instead.
 */
 function resolveCompiledSectionForegroundFromContent(content, palette, photo) {
-	if (!content) return resolveSurfaceForeground(null, palette);
-	return resolveSectionForeground(resolveSectionBackground(parseCanonicalRuntimeBackground(content), null, compiledOpeningRhythm(content), photo), palette);
+	return resolveCompiledSectionContextFromContent(content, palette, photo).openingForeground;
+}
+/** Resolve the compiled ground once for every opening appearance consumer. */
+function resolveCompiledSectionContextFromContent(content, palette, photo) {
+	const background = content ? resolveSectionBackground(parseCanonicalRuntimeBackground(content), null, compiledOpeningRhythm(content), photo) : { kind: "base" };
+	return {
+		openingForeground: resolveSectionForeground(background, palette),
+		openingPhotoBehindText: resolveSectionPhotoPlacement(background, photo) === "behind-text"
+	};
 }
 /** Legacy detached photos keep already-legible authored ink and its exact CSS treatment. */
 function sectionForegroundBackground(resolved, palette) {
@@ -14024,7 +14394,7 @@ function sectionForegroundBackground(resolved, palette) {
 	if (resolved.kind !== "content-media") return resolved.background;
 	const original = resolveSurfaceForeground(resolved.background, palette);
 	const measured = resolveSurfaceForeground(resolved.ground, palette);
-	if (original.kind === "unknown" || measured.kind === "unknown") return resolved.background;
+	if (original.kind !== "known" || measured.kind !== "known") return resolved.background;
 	const roles = [
 		"text",
 		"heading",
@@ -14129,9 +14499,9 @@ function sectionScrimSamples(background, palette) {
 	const overlay = sectionVeil(background);
 	if (overlay?.type === "gradient") return gradientScrimSamples(overlay.gradient ?? "", overlay.opacity ?? 1, palette);
 	if (overlay?.type !== "color") return [];
-	const hex = resolveConcreteColorHex(overlay.color ?? "", palette);
-	return hex ? [{
-		hex,
+	const hex$1 = resolveConcreteColorHex(overlay.color ?? "", palette);
+	return hex$1 ? [{
+		hex: hex$1,
 		alpha: overlay.opacity ?? 1
 	}] : [];
 }
@@ -14860,6 +15230,10 @@ function isRecord$1(value) {
 
 //#endregion
 //#region ../theme-core/src/header/rootPaint.ts
+/** Detached branding needs protection even when the navigation has its own rail. */
+function headerNeedsPhotoShade(header) {
+	return header.variant === "floating" && header.background?.type === "color" && header.background.color === "transparent" && (!header.container || (header.container.opacity ?? 1) < 1);
+}
 /** The nav container takes precedence when a floating header also has one. */
 function headerRootPaint(header) {
 	const navContainerType = header?.navContainer?.type ?? "none";
@@ -14992,7 +15366,7 @@ function applyFooterBackgroundOverride(theme, footer, override) {
 }
 function assertChromeBackgroundHasForeground(theme, background) {
 	const resolved = resolveSurfaceForeground(background, expandPalette(theme.palette));
-	if (resolved.kind === "unknown") {
+	if (resolved.kind !== "known") {
 		throw new Error(`Site chrome background "${background?.type === "color" ? background.color ?? "unknown" : "unknown"}" has no resolvable AA foreground; the theme palette is incomplete`);
 	}
 }
@@ -15803,6 +16177,730 @@ function resolveCardRole(theme, cardSystem, role) {
 	}
 }
 
+//#endregion
+//#region ../theme-core/src/site-styles/headerDropdownRecipe.ts
+const neutralHeaderDropdown = {
+	surface: {
+		kind: "solid",
+		background: "surface"
+	},
+	textColor: "text",
+	borderColor: "border",
+	shadow: "md",
+	borderRadius: "md",
+	textTransform: "none",
+	letterSpacing: "normal"
+};
+const brandHeaderDropdown = {
+	surface: {
+		kind: "solid",
+		background: "primary-700"
+	},
+	textColor: "primaryForeground",
+	borderColor: null,
+	shadow: "md",
+	borderRadius: "md",
+	hoverBackground: "primary-900",
+	hoverTextColor: "secondary",
+	textTransform: "uppercase",
+	letterSpacing: "wider",
+	fontWeight: "bold",
+	textSize: "sm"
+};
+const clearSplitHeaderDropdown = {
+	...neutralHeaderDropdown,
+	surface: {
+		kind: "frosted",
+		background: "surface",
+		tone: "opening",
+		opacity: .45,
+		blur: "md"
+	},
+	textColor: "text",
+	shadow: "sm",
+	borderRadius: "sm",
+	textSize: "base",
+	fontWeight: "medium",
+	hoverBackground: "text"
+};
+/** Solid menus retain their existing compiled bytes; no second runtime authority. */
+function compileHeaderDropdownRecipe(recipe) {
+	const { surface: surface$1, ...style } = recipe;
+	return {
+		...style,
+		background: surface$1.background,
+		...surface$1.kind === "frosted" ? { surfaceTreatment: {
+			kind: surface$1.kind,
+			tone: surface$1.tone,
+			opacity: surface$1.opacity,
+			blur: surface$1.blur
+		} } : {}
+	};
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/bookingPageLookIds.ts
+/** Deterministic fallback order; Fulcrum is the default. */
+const bookingPageLookIdValues = [
+	"site-style:fulcrum",
+	"site-style:folio",
+	"site-style:measure",
+	"site-style:grounded-practice",
+	"site-style:lantern",
+	"site-style:poster"
+];
+/** Boundary admission for draft and suggestion inputs. */
+function parseBookingPageLookId(value) {
+	const id$2 = bookingPageLookIdValues.find((candidate$1) => candidate$1 === value);
+	return id$2 ? asSiteStyleId(id$2) : null;
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/ownColours/bookingLookColourSpecs.ts
+const bookingLookGroundLimits = {
+	"site-style:poster": {
+		lightness: [.9, 1],
+		maxChroma: .04
+	},
+	"site-style:fulcrum": {
+		lightness: [.9, 1],
+		maxChroma: .03
+	},
+	"site-style:folio": {
+		lightness: [.88, 1],
+		maxChroma: .05
+	},
+	"site-style:measure": {
+		lightness: [.9, 1],
+		maxChroma: .02
+	},
+	"site-style:grounded-practice": {
+		lightness: [.85, 1],
+		maxChroma: .06
+	},
+	"site-style:lantern": {
+		lightness: [.12, .34],
+		maxChroma: .07
+	}
+};
+const contrast = (against, ratio$1 = 3) => ({
+	kind: "contrast",
+	against,
+	ratio: ratio$1
+});
+const distinct = (from, deltaE) => ({
+	kind: "distinct",
+	from,
+	deltaE
+});
+const label = { kind: "label" };
+/** The quiet light grounds the five light looks share: faint tints of the leading colour, inside the look's limit. */
+function lightGrounds(limits, tint$1) {
+	const page = Math.min(tint$1.page, limits.maxChroma);
+	const band = Math.min(tint$1.band, limits.maxChroma);
+	return {
+		background: {
+			l: [.955, .985],
+			c: [0, page],
+			chromaShare: .12,
+			target: .972,
+			name: "the page"
+		},
+		surface: {
+			l: [.99, 1],
+			c: [0, Math.min(page, .004)],
+			chromaShare: .04,
+			target: .997,
+			name: "the cards"
+		},
+		surfaceAlt: {
+			l: [.93, .965],
+			c: [0, band],
+			chromaShare: .25,
+			target: .948,
+			name: "the quieter panels",
+			needs: [distinct("background", .015)]
+		},
+		muted: {
+			l: tint$1.bandL,
+			c: [0, band],
+			chromaShare: .3,
+			target: (tint$1.bandL[0] + tint$1.bandL[1]) / 2,
+			name: "the band",
+			needs: [distinct("background", .03)]
+		},
+		border: {
+			l: [.8, .88],
+			c: [0, band],
+			chromaShare: .25,
+			target: .85,
+			name: "the rules"
+		}
+	};
+}
+const groundOrder = [
+	"background",
+	"surface",
+	"muted",
+	"surfaceAlt",
+	"border"
+];
+const lightReading = [
+	"background",
+	"surface",
+	"surfaceAlt",
+	"muted"
+];
+/** Fulcrum: a quiet stone page, white sheets, a strong mid-tone on the buttons, a deep plate behind the opening panel. */
+const fulcrum = {
+	roles: {
+		...lightGrounds(bookingLookGroundLimits["site-style:fulcrum"], {
+			page: .008,
+			band: .022,
+			bandL: [.9, .94]
+		}),
+		primary: {
+			l: [.3, .6],
+			c: [.04, .16],
+			target: .45,
+			name: "the buttons",
+			mention: true,
+			needs: [
+				contrast("background"),
+				contrast("surface"),
+				contrast("muted"),
+				label
+			]
+		},
+		secondary: {
+			l: [.18, .36],
+			c: [.02, .11],
+			target: .28,
+			name: "the plate",
+			mention: true,
+			needs: [contrast("surface"), distinct("primary", .08)]
+		},
+		accent: {
+			l: [.38, .72],
+			c: [.06, .17],
+			target: .62,
+			name: "the small marks",
+			analogous: true,
+			needs: [
+				contrast("background"),
+				contrast("surface"),
+				contrast("muted"),
+				distinct("primary", .1)
+			]
+		}
+	},
+	slots: [
+		{
+			roles: ["muted"],
+			name: "the band"
+		},
+		{
+			roles: ["secondary"],
+			name: "the plate"
+		},
+		{
+			roles: ["primary"],
+			name: "the buttons"
+		},
+		{
+			roles: ["accent"],
+			name: "the small marks"
+		}
+	],
+	order: [
+		...groundOrder,
+		"primary",
+		"secondary",
+		"accent"
+	],
+	neutrals: {
+		dark: [.24, .02],
+		light: [.995, .005]
+	},
+	reading: lightReading,
+	groundLimit: bookingLookGroundLimits["site-style:fulcrum"].maxChroma,
+	contrast: [{
+		label: "a muted complement on the plate",
+		hue: "complement",
+		second: "secondary",
+		lead: "primary",
+		l: .3,
+		c: [.04, .07]
+	}, {
+		label: "a warm colour on the buttons",
+		hue: "split-warm",
+		second: "primary",
+		lead: "secondary",
+		l: .45,
+		c: [.08, .13]
+	}]
+};
+/** Folio: warm paper, sheets and a band; buttons and links share the primary (hovering to its 800 shade); small rules and marks. */
+const folio = {
+	roles: {
+		...lightGrounds(bookingLookGroundLimits["site-style:folio"], {
+			page: .012,
+			band: .03,
+			bandL: [.9, .94]
+		}),
+		primary: {
+			l: [.3, .55],
+			c: [.03, .14],
+			target: .42,
+			name: "the buttons and links",
+			mention: true,
+			link: true,
+			needs: [
+				contrast("background"),
+				contrast("surface"),
+				contrast("muted"),
+				label
+			]
+		},
+		secondary: {
+			l: [.45, .62],
+			c: [.01, .04],
+			target: .54,
+			name: "the quiet details"
+		},
+		accent: {
+			l: [.38, .68],
+			c: [.05, .15],
+			target: .6,
+			name: "the marks",
+			mention: true,
+			analogous: true,
+			needs: [
+				contrast("background"),
+				contrast("surface"),
+				contrast("muted"),
+				distinct("primary", .1)
+			]
+		}
+	},
+	slots: [
+		{
+			roles: ["muted"],
+			name: "the band"
+		},
+		{
+			roles: ["primary"],
+			name: "the buttons and links"
+		},
+		{
+			roles: ["accent"],
+			name: "the marks"
+		}
+	],
+	order: [
+		...groundOrder,
+		"primary",
+		"accent",
+		"secondary"
+	],
+	neutrals: {
+		dark: [.27, .015],
+		light: [.985, .01]
+	},
+	reading: lightReading,
+	groundLimit: bookingLookGroundLimits["site-style:folio"].maxChroma,
+	contrast: [{
+		label: "the complement on the buttons and links",
+		hue: "complement",
+		second: "primary",
+		lead: "accent",
+		l: .42,
+		c: [.08, .13]
+	}, {
+		label: "a warm colour on the buttons and links",
+		hue: "split-warm",
+		second: "primary",
+		lead: "accent",
+		l: .42,
+		c: [.08, .13]
+	}]
+};
+/** Measure: one plain page. Flat buttons that fill with the secondary on hover, and a small square. */
+const measure = {
+	roles: {
+		...lightGrounds(bookingLookGroundLimits["site-style:measure"], {
+			page: .008,
+			band: .012,
+			bandL: [.91, .94]
+		}),
+		primary: {
+			l: [.18, .55],
+			c: [0, .16],
+			target: .26,
+			derivedChroma: .035,
+			name: "the buttons",
+			needs: [
+				contrast("background"),
+				contrast("surface"),
+				label
+			]
+		},
+		secondary: {
+			l: [.12, .5],
+			c: [0, .16],
+			target: {
+				from: "primary",
+				dl: -.06
+			},
+			hueFrom: "primary",
+			name: "the button hover",
+			needs: [contrast("background"), label]
+		},
+		accent: {
+			l: [.4, .7],
+			c: [.08, .2],
+			target: .55,
+			name: "the small square",
+			mention: true,
+			analogous: true,
+			needs: [
+				contrast("background"),
+				contrast("surface"),
+				distinct("primary", .1)
+			]
+		}
+	},
+	slots: [{
+		roles: ["primary"],
+		name: "the buttons"
+	}, {
+		roles: ["accent"],
+		name: "the small square"
+	}],
+	order: [
+		...groundOrder,
+		"primary",
+		"secondary",
+		"accent"
+	],
+	neutrals: {
+		dark: [.22, .012],
+		light: [.995, .004]
+	},
+	reading: lightReading,
+	groundLimit: bookingLookGroundLimits["site-style:measure"].maxChroma,
+	contrast: [{
+		label: "the complement on the square and the button hover",
+		hue: "complement",
+		second: "accent",
+		lead: "primary",
+		alsoTints: {
+			roles: ["secondary"],
+			name: "the button hover"
+		},
+		l: .55,
+		c: [.1, .17]
+	}, {
+		label: "a warm colour on the buttons",
+		hue: "split-warm",
+		second: "primary",
+		lead: "accent",
+		l: .38,
+		c: [.08, .13]
+	}]
+};
+/** Grounded Practice: an inset panel on the muted colour opens the page; links and buttons share the primary. */
+const grounded = {
+	roles: {
+		...lightGrounds(bookingLookGroundLimits["site-style:grounded-practice"], {
+			page: .012,
+			band: .04,
+			bandL: [.9, .945]
+		}),
+		primary: {
+			l: [.3, .55],
+			c: [.03, .14],
+			target: .42,
+			name: "the buttons and links",
+			mention: true,
+			link: true,
+			needs: [
+				contrast("background"),
+				contrast("muted"),
+				label,
+				{
+					kind: "ladder",
+					step: 600,
+					against: "muted",
+					ratio: 3
+				}
+			]
+		},
+		secondary: {
+			l: [.45, .62],
+			c: [.01, .04],
+			target: .54,
+			name: "the quiet details"
+		},
+		accent: {
+			l: [.38, .68],
+			c: [.05, .15],
+			target: .6,
+			name: "the small marks",
+			analogous: true,
+			needs: [contrast("background"), distinct("primary", .1)]
+		}
+	},
+	slots: [{
+		roles: ["muted"],
+		name: "the opening panel"
+	}, {
+		roles: ["primary"],
+		name: "the buttons and links"
+	}],
+	order: [
+		...groundOrder,
+		"primary",
+		"accent",
+		"secondary"
+	],
+	neutrals: {
+		dark: [.27, .015],
+		light: [.985, .01]
+	},
+	reading: lightReading,
+	groundLimit: bookingLookGroundLimits["site-style:grounded-practice"].maxChroma,
+	contrast: [{
+		label: "the complement on the buttons and links",
+		hue: "complement",
+		second: "primary",
+		lead: "muted",
+		l: .42,
+		c: [.08, .13]
+	}, {
+		label: "a warm colour on the buttons and links",
+		hue: "split-warm",
+		second: "primary",
+		lead: "muted",
+		l: .42,
+		c: [.08, .13]
+	}]
+};
+/**
+* Lantern: always dark. A very dark page, a deep band, gilt buttons running
+* from the accent into the primary (one colour family, light into deeper),
+* and the accent on every ornament and the candle glow.
+*/
+const lanternLimits = bookingLookGroundLimits["site-style:lantern"];
+const lantern = {
+	roles: {
+		background: {
+			l: [.14, .22],
+			c: [0, Math.min(.03, lanternLimits.maxChroma)],
+			chromaShare: .3,
+			target: .18,
+			name: "the page"
+		},
+		surface: {
+			l: [.24, .3],
+			c: [0, Math.min(.035, lanternLimits.maxChroma)],
+			chromaShare: .3,
+			target: .27,
+			name: "the cards",
+			needs: [distinct("background", .05)]
+		},
+		surfaceAlt: {
+			l: [.28, .34],
+			c: [0, Math.min(.035, lanternLimits.maxChroma)],
+			chromaShare: .3,
+			target: .31,
+			name: "the quieter panels"
+		},
+		muted: {
+			l: [.2, .32],
+			c: [0, lanternLimits.maxChroma],
+			chromaShare: .45,
+			target: .235,
+			name: "the band",
+			needs: [distinct("background", .04)]
+		},
+		border: {
+			l: [.35, .42],
+			c: [0, .035],
+			chromaShare: .3,
+			target: .38,
+			name: "the rules"
+		},
+		accent: {
+			l: [.76, .9],
+			c: [.03, .13],
+			target: .86,
+			name: "the ornaments and the light end of the gilt",
+			mention: true,
+			giltEnd: true,
+			hueFrom: "primary",
+			needs: [
+				contrast("background"),
+				contrast("muted"),
+				label
+			]
+		},
+		primary: {
+			l: [.62, .82],
+			c: [.03, .15],
+			target: {
+				from: "accent",
+				dl: -.11
+			},
+			hueFrom: "accent",
+			name: "the deep end of the gilt",
+			giltEnd: true,
+			needs: [
+				contrast("background"),
+				contrast("muted"),
+				label,
+				distinct("accent", .06)
+			]
+		},
+		secondary: {
+			l: [.24, .38],
+			c: [.04, .11],
+			target: .3,
+			name: "the deep details"
+		}
+	},
+	slots: [{
+		roles: ["muted"],
+		name: "the band"
+	}, {
+		roles: ["accent", "primary"],
+		name: "the gilt buttons"
+	}],
+	order: [
+		...groundOrder,
+		"accent",
+		"primary",
+		"secondary"
+	],
+	neutrals: {
+		dark: [.2, .03],
+		light: [.95, .02]
+	},
+	reading: [
+		"background",
+		"surface",
+		"surfaceAlt",
+		"muted"
+	],
+	groundLimit: lanternLimits.maxChroma,
+	contrast: [{
+		label: "a warm complement on the gilt",
+		hue: "warm-complement",
+		second: "accent",
+		lead: "muted",
+		l: .84,
+		c: [.08, .12]
+	}, {
+		label: "a second warm colour on the gilt",
+		hue: "warm-other",
+		second: "accent",
+		lead: "muted",
+		l: .84,
+		c: [.08, .12]
+	}]
+};
+/** Poster: the brand block is the one large area meant to be loud. Its buttons are the pop colour; elsewhere buttons are the block colour. */
+const posterBand = {
+	roles: ["muted", "surfaceAlt"],
+	name: "a faint tint of it on the band"
+};
+const poster = {
+	roles: {
+		...lightGrounds(bookingLookGroundLimits["site-style:poster"], {
+			page: .008,
+			band: .04,
+			bandL: [.92, .96]
+		}),
+		primary: {
+			l: [.3, .62],
+			c: [.08, .25],
+			target: .48,
+			name: "the big block",
+			mention: true,
+			needs: [
+				contrast("surface", 3.6),
+				contrast("background"),
+				label
+			]
+		},
+		accent: {
+			l: [.62, .95],
+			c: [.08, .25],
+			target: .86,
+			name: "the pop buttons and stickers",
+			mention: true,
+			analogous: true,
+			needs: [
+				contrast("primary"),
+				label,
+				distinct("primary", .15)
+			]
+		},
+		secondary: {
+			l: [.15, .32],
+			c: [.03, .15],
+			target: .24,
+			name: "the hard shadows",
+			needs: [distinct("primary", .1)]
+		}
+	},
+	slots: [{
+		roles: ["primary"],
+		name: "the big block"
+	}, {
+		roles: ["accent"],
+		name: "the pop buttons and stickers"
+	}],
+	order: [
+		...groundOrder,
+		"primary",
+		"accent",
+		"secondary"
+	],
+	neutrals: {
+		dark: [.2, .04],
+		light: [1, 0]
+	},
+	reading: lightReading,
+	groundLimit: bookingLookGroundLimits["site-style:poster"].maxChroma,
+	contrast: [{
+		label: "the complement on the pop buttons",
+		hue: "complement",
+		second: "accent",
+		lead: "primary",
+		alsoTints: posterBand,
+		l: .82,
+		c: [.12, .15]
+	}, {
+		label: "a warm triadic partner on the pop buttons",
+		hue: "triadic-warm",
+		second: "accent",
+		lead: "primary",
+		alsoTints: posterBand,
+		l: .82,
+		c: [.12, .15]
+	}]
+};
+/** Keyed by the offered looks, so a booking look without a colour spec doesn't compile. */
+const bookingLookColourSpecs = {
+	"site-style:fulcrum": fulcrum,
+	"site-style:folio": folio,
+	"site-style:measure": measure,
+	"site-style:grounded-practice": grounded,
+	"site-style:lantern": lantern,
+	"site-style:poster": poster
+};
+
 //#endregion
 //#region ../theme-core/src/site-styles/footerLookDefaults.ts
 const defaultFooterLookRecipes = {
@@ -17932,10 +19030,10 @@ function buildTextContrastShadow(input) {
 	return isLikelyLightColorToken(input.theme, input.colorToken) ? "0 1px 3px rgb(0 0 0 / 0.55), 0 0 18px rgb(0 0 0 / 0.38)" : "0 1px 3px rgb(255 255 255 / 0.72), 0 0 18px rgb(255 255 255 / 0.5)";
 }
 function isLikelyLightColorToken(theme, colorToken) {
-	const hex = resolveColorTokenHex(theme, colorToken);
-	if (hex) {
+	const hex$1 = resolveColorTokenHex(theme, colorToken);
+	if (hex$1) {
 		try {
-			return featuresFromHex(hex).Y >= .5;
+			return featuresFromHex(hex$1).Y >= .5;
 		} catch {}
 	}
 	const normalizedToken = colorToken?.toLowerCase() ?? "";
@@ -27434,6 +28532,7 @@ function resolveHeaderStyleRecipe(siteStyle, styleId) {
 const defaultHeaderStyleRecipes = {
 	minimal: {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "surface"
@@ -27452,6 +28551,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"fine-line": {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "surface"
@@ -27470,6 +28570,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"soft-bar": {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "surfaceAlt"
@@ -27490,6 +28591,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"pill-nav": {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "surface"
@@ -27515,6 +28617,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"brand-bar": {
 		tone: "brand",
+		dropdown: brandHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "primary"
@@ -27533,6 +28636,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"brand-underline": {
 		tone: "brand",
+		dropdown: brandHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "primary"
@@ -27556,6 +28660,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"brand-pill": {
 		tone: "brand",
+		dropdown: brandHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "primary"
@@ -27586,6 +28691,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"brand-capsule": {
 		tone: "brand",
+		dropdown: brandHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "primary"
@@ -27609,6 +28715,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"serif-line": {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "background"
@@ -27635,6 +28742,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"flat-tabs": {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: {
 			kind: "token",
 			token: "surface"
@@ -27653,6 +28761,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	glass: {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: { kind: "transparent" },
 		nav: {
 			kind: "pill",
@@ -27676,6 +28785,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"minimal-surface": {
 		tone: "neutral",
+		dropdown: clearSplitHeaderDropdown,
 		background: { kind: "transparent" },
 		nav: {
 			kind: "minimal",
@@ -27693,11 +28803,13 @@ const defaultHeaderStyleRecipes = {
 			contrastTreatment: "soft-glow"
 		},
 		openingForeground: "all",
+		openingPlacement: "photo-behind-text",
 		scrollTreatment: "contrast-glass",
 		interactionPalette: clearSplitInteractionPalette
 	},
 	"soft-shell": {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: { kind: "transparent" },
 		nav: {
 			kind: "pill",
@@ -27721,6 +28833,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"split-glass": {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: { kind: "transparent" },
 		nav: {
 			kind: "pill",
@@ -27744,6 +28857,7 @@ const defaultHeaderStyleRecipes = {
 	},
 	"split-pill": {
 		tone: "neutral",
+		dropdown: neutralHeaderDropdown,
 		background: { kind: "transparent" },
 		nav: {
 			kind: "pill",
@@ -27908,33 +29022,6 @@ function toneColorToken(tone) {
 		default: return assertNever$1(tone, "Unhandled header tone recipe");
 	}
 }
-function toneDropdownStyle(tone) {
-	switch (tone) {
-		case "neutral": return {
-			background: "surface",
-			textColor: "text",
-			borderColor: "border",
-			shadow: "md",
-			borderRadius: "md",
-			textTransform: "none",
-			letterSpacing: "normal"
-		};
-		case "brand": return {
-			background: "primary-700",
-			textColor: "primaryForeground",
-			borderColor: null,
-			shadow: "md",
-			borderRadius: "md",
-			hoverBackground: "primary-900",
-			hoverTextColor: "secondary",
-			textTransform: "uppercase",
-			letterSpacing: "wider",
-			fontWeight: "bold",
-			textSize: "sm"
-		};
-		default: return assertNever$1(tone, "Unhandled header tone recipe");
-	}
-}
 function recipeBackground(background) {
 	switch (background.kind) {
 		case "token": return {
@@ -28138,7 +29225,7 @@ function compileHeaderRecipe(theme, layout, recipe) {
 		...headerForLayout(layout),
 		textColor: toneColorToken(effective.tone),
 		navColor: toneColorToken(effective.tone),
-		dropdownStyle: toneDropdownStyle(effective.tone),
+		dropdownStyle: compileHeaderDropdownRecipe(effective.dropdown),
 		background: recipeBackground(effective.background),
 		border: recipeBorder(effective.border),
 		navStyle: recipeNavStyle(effective.nav),
@@ -28670,7 +29757,7 @@ function resolveCornerRadiiCss$1(cornerRadii, fallback) {
 	return `${at(cornerRadii.topLeft)} ${at(cornerRadii.topRight)} ${at(cornerRadii.bottomRight)} ${at(cornerRadii.bottomLeft)}`;
 }
 function generateCardCss(options) {
-	const { themeId, theme, cardSystem: providedCardSystem } = options;
+	const { themeId, theme, cardSystem: providedCardSystem, solvedInks } = options;
 	const tokens = new TokenResolver(theme);
 	const palette = expandPalette(theme.palette);
 	const cardSystem = providedCardSystem ?? generateDefaultCardSystem(theme);
@@ -28683,11 +29770,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, palette));
+		cssChunks.push(generateVariantCSS(variant, themeId, [`card-${variant.id}`, ...aliasClasses], tokens, theme, palette, solvedInks));
 	}
 	for (const [groupKey, group] of aliasGroups) {
 		if (emittedGroupKeys.has(groupKey)) continue;
-		cssChunks.push(generateVariantCSS(group.variant, themeId, group.classes, tokens, theme, palette));
+		cssChunks.push(generateVariantCSS(group.variant, themeId, group.classes, tokens, theme, palette, solvedInks));
 	}
 	return cssChunks.filter(Boolean).join("\n\n");
 }
@@ -28750,7 +29837,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, palette) {
+function generateVariantCSS(variant, themeId, cardClasses, tokens, theme, palette, solvedInks) {
 	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");
@@ -28758,7 +29845,7 @@ function generateVariantCSS(variant, themeId, cardClasses, tokens, theme, palett
 	const contentSelector = selectorsFor(" .card-content");
 	const fallbackBackgroundSelector = selectorsFor(" > .rb-bg-surface");
 	const rules = [];
-	rules.push(...cardSurfaceRules(variant, tokens, theme, palette));
+	rules.push(...cardSurfaceRules(variant, tokens, theme, palette, solvedInks));
 	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;
@@ -28782,7 +29869,7 @@ function generateVariantCSS(variant, themeId, cardClasses, tokens, theme, palett
 		`${contentSelector} {\n  ${contentRules.join(";\n  ")};\n}`
 	].join("\n\n");
 }
-function cardSurfaceRules(variant, tokens, theme, palette) {
+function cardSurfaceRules(variant, tokens, theme, palette, solvedInks) {
 	if (variant.background.type === "transparent") return ["background: transparent"];
 	const surface$1 = resolveSurface({
 		kind: "paint",
@@ -28790,7 +29877,8 @@ function cardSurfaceRules(variant, tokens, theme, palette) {
 	}, {
 		palette,
 		buttonSystem: theme.buttons,
-		linkHoverToken: theme.typography.proseLinkStyle?.hoverColorToken
+		linkHoverToken: theme.typography.proseLinkStyle?.hoverColorToken,
+		solvedInks
 	});
 	return [cardBackgroundRule(variant.background, tokens), ...opaqueSurfaceDeclarations(surface$1)];
 }
@@ -30215,9 +31303,9 @@ const paletteSchema = z.object({
 		return z.NEVER;
 	}
 	return {
-		colors: paletteColorEntries(colors.colors).map(({ name, hex }) => ({
+		colors: paletteColorEntries(colors.colors).map(({ name, hex: hex$1 }) => ({
 			name: String(name),
-			hex: String(hex)
+			hex: String(hex$1)
 		})),
 		meta: palette.meta
 	};
@@ -31877,38 +32965,49 @@ function renderHeaderPaintTargetRule(target, rules) {
 				"border-radius: inherit;",
 				"z-index: -1;"
 			] : [];
-			return `${target.selector} {\n  ${[...pseudoElementSetup, ...rules].join("\n  ")}\n}`;
-		}
-		case "viewport-band": {
-			const { top, bottom } = target.extent;
-			const ownerRules = [
-				`${top.customProperty}: ${top.value};`,
-				`${bottom.customProperty}: ${bottom.value};`,
-				`${top.ownerProperty}: var(${top.customProperty});`,
-				...target.ownerNeedsPositioning ? ["position: relative;"] : [],
-				"isolation: isolate;",
-				"background: none;",
-				"backdrop-filter: none;",
-				"-webkit-backdrop-filter: none;",
-				"border: 0;",
-				"box-shadow: none;"
-			];
-			const bandRules = [
-				"content: \"\";",
-				"position: absolute;",
-				`top: calc(-1 * var(${top.customProperty}));`,
-				`bottom: calc(-1 * var(${bottom.customProperty}));`,
-				"left: 50%;",
-				"width: 100vw;",
-				"transform: translateX(-50%);",
-				"pointer-events: none;",
-				"border-radius: 0;",
-				"z-index: -1;",
-				...rules
-			];
-			return `${target.clipSelector} {\n  overflow-x: clip;\n}\n${target.ownerSelector} {\n  ${ownerRules.join("\n  ")}\n}\n${target.selector} {\n  ${bandRules.join("\n  ")}\n}`;
-		}
-	}
+			const ownerInks = target.pseudoElement === "inset" ? headerPaintOwnerInks(target.selector.replace(/::before$/, ""), rules) : "";
+			return `${ownerInks}${target.selector} {\n  ${[...pseudoElementSetup, ...rules].join("\n  ")}\n}`;
+		}
+		case "viewport-band": return renderViewportBandPaint(target, rules);
+	}
+}
+function headerInkRules(rules) {
+	return rules.filter((rule$1) => Object.values(SURFACE_INK_CSS_VARS).some((variable) => rule$1.startsWith(`${variable}:`)));
+}
+function headerPaintOwnerInks(selector, rules) {
+	const inks = headerInkRules(rules);
+	return inks.length === 0 ? "" : `${selector} {\n  ${inks.join("\n  ")}\n}\n`;
+}
+/** Viewport paint stays on its pseudo-element; inherited ink belongs to the content owner. */
+function renderViewportBandPaint(target, rules) {
+	const { top, bottom } = target.extent;
+	const ownerRules = [
+		`${top.customProperty}: ${top.value};`,
+		`${bottom.customProperty}: ${bottom.value};`,
+		`${top.ownerProperty}: var(${top.customProperty});`,
+		...target.ownerNeedsPositioning ? ["position: relative;"] : [],
+		"isolation: isolate;",
+		"background: none;",
+		"backdrop-filter: none;",
+		"-webkit-backdrop-filter: none;",
+		"border: 0;",
+		"box-shadow: none;",
+		...headerInkRules(rules)
+	];
+	const bandRules = [
+		"content: \"\";",
+		"position: absolute;",
+		`top: calc(-1 * var(${top.customProperty}));`,
+		`bottom: calc(-1 * var(${bottom.customProperty}));`,
+		"left: 50%;",
+		"width: 100vw;",
+		"transform: translateX(-50%);",
+		"pointer-events: none;",
+		"border-radius: 0;",
+		"z-index: -1;",
+		...rules
+	];
+	return `${target.clipSelector} {\n  overflow-x: clip;\n}\n${target.ownerSelector} {\n  ${ownerRules.join("\n  ")}\n}\n${target.selector} {\n  ${bandRules.join("\n  ")}\n}`;
 }
 
 //#endregion
@@ -31932,7 +33031,8 @@ function generateHeaderScrollTreatmentStyles(treatment, themeId, variant, surfac
 				`background-color: rgb(${backgroundChannels} / 0.60);`,
 				`backdrop-filter: ${CONTRAST_GLASS_BLUR};`,
 				`-webkit-backdrop-filter: ${CONTRAST_GLASS_BLUR};`,
-				...surfaceRules
+				...surfaceRules,
+				...surfaceInkDeclarations({ kind: "reset" }).map((rule$1) => rule$1.replace(";", " !important;"))
 			]);
 		}
 	}
@@ -32200,6 +33300,12 @@ const dropdownStyleSchema = z.object({
 		"md",
 		"lg"
 	]).default("md"),
+	surfaceTreatment: z.discriminatedUnion("kind", [z.object({ kind: z.literal("solid") }), z.object({
+		kind: z.literal("frosted"),
+		tone: z.enum(["fixed", "opening"]),
+		opacity: z.number().min(0).max(1),
+		blur: z.enum(["sm", "md"])
+	})]).optional(),
 	hoverBackground: themeColorTokenSchema.nullable().optional(),
 	hoverTextColor: themeColorTokenSchema.nullable().optional(),
 	textTransform: z.enum([
@@ -33239,8 +34345,8 @@ function getGradientPreset(id$2) {
 */
 function gradientToCss(config, tokens) {
 	const stops = config.stops.map((stop) => {
-		const hex = tokens[stop.color] ?? "#000000";
-		return `${hex} ${stop.position}%`;
+		const hex$1 = tokens[stop.color] ?? "#000000";
+		return `${hex$1} ${stop.position}%`;
 	}).join(", ");
 	const type = config.type ?? "linear";
 	if (type === "radial") {
@@ -33366,8 +34472,8 @@ function gradientMediaScrim(input) {
 function scrimOpacityFor(scrimHex, foreground, palette) {
 	if (typeof scrimHex !== "string") return { kind: "unreadable" };
 	const foregroundHexes = Object.values(foreground).flatMap((token) => {
-		const hex = typeof token === "string" ? palette[token] : undefined;
-		return typeof hex === "string" ? [hex] : [];
+		const hex$1 = typeof token === "string" ? palette[token] : undefined;
+		return typeof hex$1 === "string" ? [hex$1] : [];
 	});
 	if (foregroundHexes.length === 0) return { kind: "unreadable" };
 	const opacity = minimumScrimOpacity({
@@ -33513,13 +34619,13 @@ function surfaceResolutionContextFromPalette(palette) {
 		buttonSystem: undefined
 	});
 }
-function surfaceResolutionContextFromTheme(theme, declaredSurfaces = []) {
+function surfaceResolutionContextFromTheme(theme, declaredSurfaces = [], solvedInks) {
 	return prepareThemeSurfaceRevision({
 		palette: theme.palette,
 		buttons: theme.buttons,
 		skin: theme.skin,
 		skinMarks: theme.skinMarks
-	}, () => declaredSurfaces).context;
+	}, () => declaredSurfaces, solvedInks).context;
 }
 function defineDesignRuntimeRules(rules) {
 	return rules;
@@ -34194,8 +35300,11 @@ const bookingPageNoPhotoHeroLookIds = {
 	"site-style:poster": "hero-page-head"
 };
 function bookingPageOfferingFor(siteStyleId) {
-	const entry = Object.entries(bookingPageNoPhotoHeroLookIds).find(([id$2]) => id$2 === siteStyleId);
-	return entry ? { noPhotoHeroLookId: asAppearancePresetId(entry[1]) } : undefined;
+	const lookId = bookingPageLookIdValues.find((id$2) => id$2 === siteStyleId);
+	return lookId ? {
+		noPhotoHeroLookId: asAppearancePresetId(bookingPageNoPhotoHeroLookIds[lookId]),
+		colourSpec: bookingLookColourSpecs[lookId]
+	} : undefined;
 }
 function clientStyleMatchesSite(siteSlugs, target) {
 	if (target.audience !== "site-picker" && target.audience !== "local-demo") return false;
@@ -34555,7 +35664,11 @@ const headerCurationBySiteStyle = {
 	"site-style:folio": defineHeaderCuration([
 		{
 			layoutId: "floating",
-			styleIds: ["minimal-surface", "glass"]
+			styleIds: [
+				"minimal-surface",
+				"soft-shell",
+				"glass"
+			]
 		},
 		{
 			layoutId: "classic",
@@ -35239,6 +36352,11 @@ const folioLooks = {
 			treatment: "hero-short-panel",
 			roleMap: folioRoles
 		},
+		{
+			id: id("hero-text-over-photo"),
+			treatment: "hero-photo-overlay",
+			roleMap: folioRoles
+		},
 		{
 			id: id("hero-page-head"),
 			treatment: "hero-ruled",
@@ -35289,10 +36407,7 @@ const folioLooks = {
 			id: id("event-calendar-ruled-rows"),
 			treatment: "calendar-card",
 			itemRoles: { container: "card" },
-			surfaceTints: { date: {
-				source: "text",
-				opacity: 8
-			} },
+			knobValues: { actionStyle: ["button"] },
 			roleMap: folioRoles
 		},
 		{
@@ -35303,6 +36418,7 @@ const folioLooks = {
 		{
 			id: id("event-calendar-next-three"),
 			treatment: "calendar-compact",
+			knobValues: { actionStyle: ["button"] },
 			roleMap: folioRoles
 		},
 		{
@@ -37708,12 +38824,15 @@ const curatedSiteStyles = [
 			accordions: editorialDividedAccordionSystem,
 			testimonialQuote: serifDisplayQuote
 		},
-		headerStyleRecipes: { "minimal-surface": {
+		headerStyleRecipes: { "soft-shell": {
 			tone: "neutral",
+			dropdown: neutralHeaderDropdown,
 			background: { kind: "transparent" },
 			nav: {
-				kind: "minimal",
-				hoverColorToken: "primary"
+				kind: "pill",
+				backing: "capsule",
+				hoverColorToken: "primary",
+				hoverAlpha: 8
 			},
 			navWeight: "medium",
 			navLinkWeight: "medium",
@@ -37805,6 +38924,7 @@ const curatedSiteStyles = [
 		},
 		headerStyleRecipes: { "serif-line": {
 			tone: "neutral",
+			dropdown: neutralHeaderDropdown,
 			background: {
 				kind: "token",
 				token: "background"
@@ -38554,8 +39674,8 @@ function validateLookFallbacks(style, catalogue = appearancePresets.filter(isArr
 function validateCalendarModeOffers(style, catalogue = appearancePresets.filter(isArrangementAppearancePreset)) {
 	const calendarLooks = catalogue.filter((look$1) => look$1.blockKinds.includes("block.event-calendar"));
 	arrangementModes.forEach((mode) => {
-		const offered = calendarLooks.some((look$1) => lookModes(look$1).includes(mode) && style.offers.some((offer) => offer.id === look$1.id));
-		if (!offered) throw new Error(`Missing automatic calendar Look for ${style.skin}: ${mode}`);
+		const offered$1 = calendarLooks.some((look$1) => lookModes(look$1).includes(mode) && style.offers.some((offer) => offer.id === look$1.id));
+		if (!offered$1) throw new Error(`Missing automatic calendar Look for ${style.skin}: ${mode}`);
 	});
 }
 function fallbackEndsAtOffer(entry, mode, style, catalogue, visited) {
@@ -38977,12 +40097,12 @@ function autoEditorChoice(effectiveValue) {
 	};
 }
 function userPinnedEditorChoice(value, input = {}) {
-	const status = input.status ?? "supported";
+	const status$1 = input.status ?? "supported";
 	return {
 		kind: "user-pinned",
 		value,
-		status,
-		effectiveValue: input.effectiveValue !== undefined ? input.effectiveValue : status === "supported" ? value : null
+		status: status$1,
+		effectiveValue: input.effectiveValue !== undefined ? input.effectiveValue : status$1 === "supported" ? value : null
 	};
 }
 const backgroundImagePromotedFieldPath = "_sectionStyles.background.image";
@@ -39450,8 +40570,8 @@ function compileFooterAgainstRow(input) {
 }
 /** Style switches retain an offered choice; otherwise use the style's first choice. */
 function resolveFooterLookIdForStyle(siteStyle, current) {
-	const offered = siteStyle?.recommendedFooterLookIds ?? [guaranteedFallbackFooterLookId];
-	return current !== null && offered.includes(current) ? current : offered[0] ?? guaranteedFallbackFooterLookId;
+	const offered$1 = siteStyle?.recommendedFooterLookIds ?? [guaranteedFallbackFooterLookId];
+	return current !== null && offered$1.includes(current) ? current : offered$1[0] ?? guaranteedFallbackFooterLookId;
 }
 
 //#endregion
@@ -40775,7 +41895,35 @@ function mergeBodyTextOverride(theme, override) {
 		...intro ? { intro } : {}
 	});
 }
-function withSiteStyleMetadata({ skin: _previousSkin, skinTokens: _previousTokens, fontLoading: _previousFonts, skinMarks: _previousMarks, ...theme }, siteStyle) {
+function siteStyleLookMetadata(siteStyle) {
+	const looks = siteStyle.looks;
+	return looks.kind === "offers" ? {
+		skin: looks.skin,
+		skinTokens: looks.skinTokens,
+		fontLoading: looks.fontLoading,
+		...looks.marksFrom === undefined ? {} : { skinMarks: looks.marksFrom }
+	} : {};
+}
+function withoutLookMetadata({ skin: _previousSkin, skinTokens: _previousTokens, fontLoading: _previousFonts, skinMarks: _previousMarks, ...theme }) {
+	return theme;
+}
+/** Repair absent applied skin fields without refreshing an existing design from the catalogue. */
+function fillMissingSiteStyleLookMetadata(theme) {
+	const siteStyle = theme.siteStyleId === undefined ? null : getCuratedSiteStyle(theme.siteStyleId);
+	if (siteStyle === null) return theme;
+	const looks = siteStyle.looks;
+	if (looks.kind !== "offers") return withoutLookMetadata(theme);
+	return {
+		...theme,
+		skin: theme.skin ?? looks.skin,
+		skinTokens: theme.skinTokens ?? looks.skinTokens,
+		fontLoading: theme.fontLoading ?? looks.fontLoading,
+		...theme.skinMarks === undefined && looks.marksFrom !== undefined ? { skinMarks: looks.marksFrom } : {}
+	};
+}
+/** Full style Apply deliberately replaces applied skin output with the current catalogue. */
+function withSiteStyleMetadata(previous, siteStyle) {
+	const theme = withoutLookMetadata(previous);
 	const surfaceContexts = siteStyle.looks.kind === "offers" ? Object.fromEntries(Object.values(siteStyle.looks.surfaces).flatMap((spec) => spec.kind === "token" && spec.buttonContext ? [[spec.token, spec.buttonContext]] : [])) : {};
 	return {
 		...theme,
@@ -40787,12 +41935,7 @@ function withSiteStyleMetadata({ skin: _previousSkin, skinTokens: _previousToken
 		description: siteStyle.description,
 		rationale: `Compiled from curated Theme V2 site style ${siteStyle.id}.`,
 		siteStyleId: siteStyle.id,
-		...siteStyle.looks.kind === "offers" ? {
-			skin: siteStyle.looks.skin,
-			skinTokens: siteStyle.looks.skinTokens,
-			fontLoading: siteStyle.looks.fontLoading,
-			...siteStyle.looks.marksFrom === undefined ? {} : { skinMarks: siteStyle.looks.marksFrom }
-		} : {},
+		...siteStyleLookMetadata(siteStyle),
 		headingDecoration: siteStyle.headingDecoration
 	};
 }
@@ -42304,8 +43447,8 @@ 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 withOpeningForegroundProjection(applyUnknownOpeningForegroundFallback(theme, header), foreground);
+	const foreground = context?.openingForeground ?? { kind: "unmeasured-paint" };
+	if (foreground.kind !== "known") return withOpeningForegroundProjection(applyUnknownOpeningForegroundFallback(theme, header), foreground);
 	return projectKnownOpeningForeground(theme, header, recipe, foreground);
 }
 function projectKnownOpeningForeground(theme, header, recipe, foreground) {
@@ -43292,23 +44435,6 @@ const decodedPageDesignIntentSchema = z.union([z.nullish(z.never()).transform(()
 	return typeof value === "object" && value !== null && "schemaVersion" in value && value.schemaVersion !== 2 ? "Unsupported page design decisions schemaVersion." : "Invalid page design decisions shape.";
 } });
 
-//#endregion
-//#region ../theme-core/src/site-styles/bookingPageLookIds.ts
-/** Deterministic fallback order; Fulcrum is the default. */
-const bookingPageLookIdValues = [
-	"site-style:fulcrum",
-	"site-style:folio",
-	"site-style:measure",
-	"site-style:grounded-practice",
-	"site-style:lantern",
-	"site-style:poster"
-];
-/** Boundary admission for draft and suggestion inputs. */
-function parseBookingPageLookId(value) {
-	const id$2 = bookingPageLookIdValues.find((candidate$1) => candidate$1 === value);
-	return id$2 ? asSiteStyleId(id$2) : null;
-}
-
 //#endregion
 //#region ../theme-core/src/site-styles/appearance.ts
 const bookingPageLooks = bookingPageLookIdValues.map((value) => {
@@ -43433,6 +44559,907 @@ function describeAppearance(value) {
 	};
 }
 
+//#endregion
+//#region ../theme-core/src/site-styles/ownColours/types.ts
+const groundRoles = [
+	"background",
+	"surface",
+	"surfaceAlt",
+	"muted",
+	"border"
+];
+const paintedRoles = [
+	...groundRoles,
+	"primary",
+	"secondary",
+	"accent"
+];
+
+//#endregion
+//#region ../theme-core/src/site-styles/ownColours/colourSpace.ts
+/** Below this OKLCH chroma a colour has no hue worth carrying (greys, black, white). */
+const ACHROMATIC_CHROMA = .02;
+const wrapHue = (degrees) => (degrees % 360 + 360) % 360;
+/** The angle between two hues, 0–180. */
+const hueGap = (a, b) => Math.abs((a - b + 540) % 360 - 180);
+function lchOf(hex$1) {
+	const { okL, okC, okH } = featuresFromHex(hex$1);
+	return {
+		l: okL,
+		c: okC,
+		h: okH
+	};
+}
+/** The in-gamut sRGB colour nearest this OKLCH, holding lightness and hue and reducing chroma. */
+function fromLch(l, c, h) {
+	const lightness = Math.min(1, Math.max(0, l));
+	const chroma = gamutChroma(lightness, Math.max(0, c), wrapHue(h));
+	const { r, g, b } = oklchToLinearSrgb(lightness, chroma, wrapHue(h));
+	return hexColorSchema.parse(rgbToHex(linearToSrgb(r), linearToSrgb(g), linearToSrgb(b)));
+}
+/**
+* A shade of a hue at another lightness. Yellows and olives turn toward
+* orange as they darken, as a painter would shade them, so a deep mustard
+* reads as ochre rather than khaki.
+*/
+function shadeAt(l, c, h, fromL) {
+	const turn = h >= 55 && h <= 115 && l < fromL ? Math.min(25, (fromL - l) * 50) : 0;
+	return fromLch(l, c, h - turn);
+}
+function oklabOf(hex$1) {
+	const { r, g, b } = hexToRgb(hex$1);
+	return srgbToOklab(r, g, b);
+}
+/** OKLab ΔE between two colours. */
+function colourDistance(a, b) {
+	return oklabDistance(oklabOf(a), oklabOf(b));
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/ownColours/engine.ts
+const hex = (value) => hexColorSchema.parse(value.toLowerCase());
+const clamp = (value, [lo, hi]) => Math.min(hi, Math.max(lo, value));
+const isGround = (role) => groundRoles.includes(role);
+const STEP = .005;
+function lightnessSteps([lo, hi]) {
+	const count = Math.floor((hi - lo + 1e-9) / STEP) + 1;
+	return Array.from({ length: count }, (_, i) => Math.round((lo + i * STEP) * 1e3) / 1e3);
+}
+/** The first of the cheapest, so ties keep the search's own order. */
+function cheapest(options) {
+	return options.reduce((best, next) => !best || next.cost < best.cost ? next : best, undefined);
+}
+const labelReads = (fill) => maxContrastBlackOrWhite(solidPaint(fill)).ratio >= 4.5;
+function meets(candidate$1, needs, placed) {
+	return needs.every((need) => {
+		switch (need.kind) {
+			case "label": return labelReads(candidate$1);
+			case "ladder": {
+				const ground = placed[need.against];
+				const step = generateShades(candidate$1, "x").find((entry) => entry.name === `x-${need.step}`);
+				return !ground || !step || contrastRatio(step.hex, ground) >= need.ratio;
+			}
+			case "contrast": {
+				const other = placed[need.against];
+				return !other || contrastRatio(candidate$1, other) >= need.ratio;
+			}
+			case "distinct": {
+				const other = placed[need.from];
+				return !other || colourDistance(candidate$1, other) >= need.deltaE;
+			}
+		}
+	});
+}
+/** A role's own needs, plus every painted role's needs that point back at it, turned round. */
+function needsFor(spec, role, placed) {
+	const reverse = paintedRoles.flatMap((other) => {
+		if (!placed[other]) return [];
+		return (spec.roles[other].needs ?? []).flatMap((need) => {
+			if (need.kind === "contrast" && need.against === role) return [{
+				kind: "contrast",
+				against: other,
+				ratio: need.ratio
+			}];
+			if (need.kind === "distinct" && need.from === role) return [{
+				kind: "distinct",
+				from: other,
+				deltaE: need.deltaE
+			}];
+			return [];
+		});
+	});
+	return [...spec.roles[role].needs ?? [], ...reverse];
+}
+const linkReads = (candidate$1, placed) => ["background", "surface"].every((ground) => {
+	const paint = placed[ground];
+	return !paint || contrastRatio(candidate$1, paint) >= 4.5;
+});
+/** The solver's family ink for a link role: the owner's colour moved at most ΔE 0.08 to read on the page and cards. */
+function linkInk(colour, placed) {
+	const { background, surface: surface$1 } = placed;
+	if (!background || !surface$1) return [];
+	const lo = Math.min(hexLuminance(background), hexLuminance(surface$1));
+	const hi = Math.max(hexLuminance(background), hexLuminance(surface$1));
+	const ink = inkFrom(colourFamily(colour), luminanceInterval(lo, hi), 4.5);
+	return ink.kind === "ink" ? [hex(ink.hex)] : [];
+}
+function inRange(roleSpec, candidate$1) {
+	const { l, c } = lchOf(candidate$1);
+	return l >= roleSpec.l[0] - .001 && l <= roleSpec.l[1] + .001 && c <= roleSpec.c[1] + .004;
+}
+/**
+* A held colour in a role: exactly when it fits, otherwise its nearest shade
+* inside the role's range that meets its needs. A link role first offers the
+* solver's family ink within ΔE 0.08; a link that still misses 4.5:1 ranks as
+* if it had moved that far, so a close shade that reads wins.
+*/
+function hold(spec, role, colour, placed) {
+	const roleSpec = spec.roles[role];
+	const needs = needsFor(spec, role, placed);
+	const s = lchOf(colour);
+	const linkPenalty = (candidate$1) => roleSpec.link && !linkReads(candidate$1, placed) ? BRAND_INK_MAX_DELTA_E : 0;
+	const chroma = clamp(s.c, [Math.min(roleSpec.c[0], s.c), roleSpec.c[1]]);
+	const candidates = [
+		colour,
+		...roleSpec.link ? linkInk(colour, placed) : [],
+		...lightnessSteps(roleSpec.l).map((l) => shadeAt(l, chroma, s.h, s.l))
+	];
+	const best = cheapest(candidates.filter((candidate$1) => inRange(roleSpec, candidate$1) && meets(candidate$1, needs, placed)).map((candidate$1) => ({
+		hex: candidate$1,
+		cost: colourDistance(candidate$1, colour) + linkPenalty(candidate$1)
+	})));
+	return best ? {
+		kind: "fitted",
+		hex: best.hex
+	} : {
+		kind: "unfit",
+		reason: {
+			kind: "role-unmet",
+			role
+		}
+	};
+}
+/** The chroma a derived role takes from its source: a share of it, inside the role's range; none from a grey. */
+function derivedChroma(roleSpec, sourceChroma) {
+	if (sourceChroma < ACHROMATIC_CHROMA) return 0;
+	const wanted = Math.min(sourceChroma * (roleSpec.chromaShare ?? 1), roleSpec.derivedChroma ?? Infinity);
+	return clamp(wanted, [Math.min(roleSpec.c[0], sourceChroma), roleSpec.c[1]]);
+}
+function targetLightness(roleSpec, source, placed) {
+	if (typeof roleSpec.target === "number") return roleSpec.target;
+	return clamp(lchOf(placed[roleSpec.target.from] ?? source).l + roleSpec.target.dl, roleSpec.l);
+}
+/** An unheld role, as a shade or tint of its source's hue inside the role's range, as near its target lightness as its needs allow. */
+function derive(spec, role, source, placed) {
+	const roleSpec = spec.roles[role];
+	const needs = needsFor(spec, role, placed);
+	const s = lchOf(source);
+	const target = targetLightness(roleSpec, source, placed);
+	const chroma = derivedChroma(roleSpec, s.c);
+	const turns = roleSpec.analogous ? [
+		0,
+		20,
+		-20,
+		40,
+		-40
+	] : [0];
+	const best = cheapest(turns.flatMap((turn) => lightnessSteps(roleSpec.l).flatMap((l) => {
+		const candidate$1 = shadeAt(l, chroma, s.h + turn, s.l);
+		return inRange(roleSpec, candidate$1) && meets(candidate$1, needs, placed) ? [{
+			hex: candidate$1,
+			cost: Math.abs(l - target) + .004 * Math.abs(turn)
+		}] : [];
+	})));
+	return best ? {
+		kind: "fitted",
+		hex: best.hex
+	} : {
+		kind: "unfit",
+		reason: {
+			kind: "role-unmet",
+			role
+		}
+	};
+}
+const holdsGround = (entry) => entry.slot.roles.some(isGround);
+/** Each held colour, in the slot role it fits with the smallest move. */
+function holdPhase(spec, holds, start) {
+	return holds.reduce((result, entry) => {
+		if (result.kind === "unfit") return result;
+		const { placed, held } = result.painting;
+		const fits = entry.slot.roles.flatMap((role) => {
+			const fitted = hold(spec, role, entry.hex, placed);
+			return fitted.kind === "fitted" ? [{
+				role,
+				hex: fitted.hex,
+				cost: colourDistance(fitted.hex, entry.hex)
+			}] : [];
+		});
+		const best = cheapest(fits);
+		if (!best) return {
+			kind: "unfit",
+			reason: {
+				kind: "role-unmet",
+				role: entry.slot.roles[0]
+			}
+		};
+		const landed = {
+			source: entry.source,
+			slot: entry.slot,
+			role: best.role,
+			hex: best.hex,
+			asked: entry.hex,
+			deltaE: best.cost
+		};
+		return {
+			kind: "painting",
+			painting: {
+				placed: {
+					...placed,
+					[best.role]: best.hex
+				},
+				held: [...held, landed]
+			}
+		};
+	}, {
+		kind: "painting",
+		painting: start
+	});
+}
+/** The colour an unheld role takes its hue from. Grounds follow a colour already held on a ground, so the page and a held band agree. */
+function sourceFor(spec, role, request, painting) {
+	const given = request.hueSources?.[role];
+	if (given) return given;
+	const linked = spec.roles[role].hueFrom;
+	const fromRole = linked ? painting.placed[linked] : undefined;
+	if (fromRole) return fromRole;
+	return isGround(role) ? groundTint(painting, request.lead) : request.lead;
+}
+function groundTint(painting, lead) {
+	return painting.held.find((entry) => isGround(entry.role))?.asked ?? lead;
+}
+function derivePhase(spec, roles, request, start) {
+	return roles.reduce((result, role) => {
+		if (result.kind === "unfit" || result.painting.placed[role]) return result;
+		const { painting } = result;
+		const fitted = derive(spec, role, sourceFor(spec, role, request, painting), painting.placed);
+		if (fitted.kind === "unfit") return fitted;
+		return {
+			kind: "painting",
+			painting: {
+				...painting,
+				placed: {
+					...painting.placed,
+					[role]: fitted.hex
+				}
+			}
+		};
+	}, start);
+}
+/** Every painted role, or the first one missing. */
+function complete(placed) {
+	const { background, surface: surface$1, surfaceAlt, muted, border: border$1, primary, secondary, accent } = placed;
+	if (background && surface$1 && surfaceAlt && muted && border$1 && primary && secondary && accent) {
+		return {
+			kind: "complete",
+			roles: {
+				background,
+				surface: surface$1,
+				surfaceAlt,
+				muted,
+				border: border$1,
+				primary,
+				secondary,
+				accent
+			}
+		};
+	}
+	const missing = paintedRoles.find((role) => !placed[role]) ?? "primary";
+	return {
+		kind: "unfit",
+		reason: {
+			kind: "role-unmet",
+			role: missing
+		}
+	};
+}
+/** Status colours keep their meaning (green, amber, red); they are semantic, not part of the look. */
+const statusHues = {
+	success: 150,
+	warning: 70,
+	destructive: 27
+};
+function status(hue, background, dark) {
+	const fits = (l$1) => contrastRatio(fromLch(l$1, .13, hue), background) >= 3;
+	const l = (dark ? lightnessSteps([.6, .95]) : lightnessSteps([.2, .6]).reverse()).find(fits) ?? (dark ? .95 : .2);
+	return fromLch(l, .13, hue);
+}
+/** The inks and status colours, solved for the painted roles. */
+function finish(spec, roles, tintToward) {
+	const { c, h } = lchOf(tintToward);
+	const tint$1 = Math.min(c, .03);
+	const preferred = {
+		dark: fromLch(spec.neutrals.dark[0], Math.min(tint$1, spec.neutrals.dark[1]), h),
+		light: fromLch(spec.neutrals.light[0], Math.min(tint$1, spec.neutrals.light[1]), h)
+	};
+	const ys = spec.reading.map((role) => hexLuminance(roles[role]));
+	const text = neutralInk(luminanceInterval(Math.min(...ys), Math.max(...ys)), 4.5, preferred);
+	const onPrimary = neutralInk(solidPaint(roles.primary), 4.5, preferred);
+	if (text.kind !== "ink" || onPrimary.kind !== "ink") return {
+		kind: "unfit",
+		reason: { kind: "no-readable-text" }
+	};
+	const dark = maxContrastBlackOrWhite(solidPaint(roles.background)).ink === "white";
+	return {
+		kind: "finished",
+		colors: {
+			...roles,
+			success: status(statusHues.success, roles.background, dark),
+			warning: status(statusHues.warning, roles.background, dark),
+			destructive: status(statusHues.destructive, roles.background, dark),
+			text: hex(text.hex),
+			primaryForeground: hex(onPrimary.hex)
+		},
+		mode: dark ? "dark" : "light"
+	};
+}
+/**
+* A band or panel is always a pale or deep tint of a colour, so moving a
+* colour there counts for less than shading a button colour.
+*/
+const GROUND_MOVE_WEIGHT = .3;
+/** One complete palette for the look: held grounds, derived grounds, held fills, derived fills, then inks. */
+function paintPalette(spec, request) {
+	const start = {
+		placed: {},
+		held: []
+	};
+	const grounds = derivePhase(spec, spec.order.filter(isGround), request, holdPhase(spec, request.holds.filter(holdsGround), start));
+	if (grounds.kind === "unfit") return grounds;
+	const fills = derivePhase(spec, spec.order.filter((role) => !isGround(role)), request, holdPhase(spec, request.holds.filter((entry) => !holdsGround(entry)), grounds.painting));
+	if (fills.kind === "unfit") return fills;
+	const roles = complete(fills.painting.placed);
+	if (roles.kind === "unfit") return roles;
+	const finished = finish(spec, roles.roles, groundTint(fills.painting, request.lead));
+	if (finished.kind === "unfit") return finished;
+	const { held } = fills.painting;
+	return {
+		kind: "painted",
+		colors: finished.colors,
+		mode: finished.mode,
+		held,
+		cost: held.reduce((sum, entry) => sum + entry.deltaE * (isGround(entry.role) ? GROUND_MOVE_WEIGHT : 1), 0)
+	};
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/ownColours/ownColourPalettes.ts
+/** Amber in OKLCH; warmth is closeness to it. */
+const WARM_CENTRE = 60;
+const warmth = (h) => hueGap(h, WARM_CENTRE);
+/** Rose round to gold (OKLCH 340° to 110°). */
+const isWarm = (h) => h >= 340 || h <= 110;
+/**
+* Hues that look muddy or sweet as a contrast (olive and forest greens,
+* orchids and magentas) move to their warmer neighbour: plum's complement
+* becomes gold, sage's becomes rose.
+*/
+function outOfMud(h) {
+	if (h > 110 && h < 165) return 105;
+	if (h > 295 && h < 350) return 355;
+	return h;
+}
+/** Steps round the wheel, 15° apart, from straight across inwards. */
+const steps = [180, ...[
+	165,
+	150,
+	135,
+	120,
+	105,
+	90,
+	75,
+	60,
+	45,
+	30
+].flatMap((o) => [o, -o])];
+const warmChoices = [
+	"warm-complement",
+	"split-warm",
+	"triadic-warm",
+	"warm-other"
+];
+function preferredHues(choice, lead) {
+	const byWarmth = (offsets) => offsets.map((o) => wrapHue(lead + o)).sort((a, b) => warmth(a) - warmth(b));
+	const warmest = () => byWarmth(steps).filter(isWarm);
+	switch (choice) {
+		case "complement": return byWarmth([
+			165,
+			180,
+			195
+		]);
+		case "warm-complement": {
+			const across = byWarmth([
+				165,
+				180,
+				195
+			])[0] ?? wrapHue(lead + 180);
+			return isWarm(across) ? [across, ...warmest()] : warmest();
+		}
+		case "split-warm": return [...byWarmth([150, -150]).filter(isWarm), ...warmest()];
+		case "triadic-warm": return [...byWarmth([120, -120]).filter(isWarm), ...warmest()];
+		case "warm-other": return warmest();
+	}
+}
+/**
+* The hues a rule tries, in tiers, best first. Warm rules keep 45° from a
+* warm brand's own hue, and only when nothing warm is left (terracotta,
+* mustard) turn to the cool complement (deep teal, ink blue). Every hue is
+* kept out of the muddy zones and 40° clear of the other rule's colour. The
+* last tier is any step round the wheel, for when nothing earlier looks
+* different enough from the palettes before it.
+*/
+function candidateHues(rule$1, lead, avoid) {
+	const warmRule = warmChoices.includes(rule$1.hue);
+	const leadGap = warmRule ? 45 : 30;
+	const clear = (h) => hueGap(h, lead) >= leadGap && (avoid === null || hueGap(h, avoid) >= 40);
+	const unique = (hues) => hues.filter((h, i) => hues.findIndex((other) => Math.abs(other - h) < 1) === i);
+	const own = unique(preferredHues(rule$1.hue, lead).map(outOfMud).filter(clear));
+	const cool = own.length > 0 ? [] : unique(preferredHues("complement", lead).map(outOfMud).filter(clear));
+	const anyStep = unique(steps.map((o) => outOfMud(wrapHue(lead + o))).filter((h) => hueGap(h, lead) >= 30));
+	return [
+		own,
+		cool,
+		anyStep
+	];
+}
+/**
+* The rule's second colour at a hue, before it is fitted to its role. Deep
+* yellows would read as olive and brown, so a deep rule paints amber and
+* ochre a little lighter, turned toward orange.
+*/
+function madeColour(rule$1, lead, hue) {
+	const s = lchOf(lead);
+	const yellow = hue >= 55 && hue <= 105;
+	const l = rule$1.l < .5 && yellow ? rule$1.l + .12 : rule$1.l;
+	const turn = hue >= 55 && hue <= 115 && l < .85 ? Math.min(35, (.85 - l) * 70) : 0;
+	return fromLch(l, Math.min(rule$1.c[1], Math.max(rule$1.c[0], s.c)), hue - turn);
+}
+/** [hue upper bound, dark, mid, light] in OKLCH hue. */
+const names = [
+	[
+		20,
+		"burgundy",
+		"rose",
+		"pink"
+	],
+	[
+		38,
+		"oxblood",
+		"coral",
+		"pale coral"
+	],
+	[
+		60,
+		"rust",
+		"orange",
+		"peach"
+	],
+	[
+		78,
+		"bronze",
+		"amber",
+		"apricot"
+	],
+	[
+		100,
+		"ochre",
+		"gold",
+		"pale gold"
+	],
+	[
+		122,
+		"olive",
+		"yellow",
+		"pale yellow"
+	],
+	[
+		160,
+		"forest green",
+		"green",
+		"pale green"
+	],
+	[
+		182,
+		"deep jade",
+		"jade",
+		"mint"
+	],
+	[
+		228,
+		"deep teal",
+		"teal",
+		"aqua"
+	],
+	[
+		258,
+		"deep blue",
+		"blue",
+		"pale blue"
+	],
+	[
+		288,
+		"navy",
+		"blue",
+		"periwinkle"
+	],
+	[
+		318,
+		"indigo",
+		"violet",
+		"lavender"
+	],
+	[
+		348,
+		"plum",
+		"magenta",
+		"orchid"
+	],
+	[
+		361,
+		"burgundy",
+		"rose",
+		"pink"
+	]
+];
+/** A plain name for a colour the look made, as an owner would say it. */
+function colourName(hex$1) {
+	const { l, c, h } = lchOf(hex$1);
+	if (c < .025) return l > .9 ? "off-white" : l < .3 ? "near-black" : l > .7 ? "pale grey" : "grey";
+	const [, dark, mid, light] = names.find(([upTo]) => h < upTo) ?? names[names.length - 1] ?? [
+		361,
+		"grey",
+		"grey",
+		"grey"
+	];
+	if (l < .42) return dark;
+	if (l > .8) return light;
+	return c < .06 ? `muted ${mid}` : mid;
+}
+const sentence = (text) => `${text.charAt(0).toUpperCase()}${text.slice(1)}.`;
+function shadeWords(asked, drawn) {
+	const dl = lchOf(drawn).l - lchOf(asked).l;
+	return dl < -.25 ? "a deep shade of" : dl < 0 ? "a deeper shade of" : dl > .25 ? "a pale shade of" : "a lighter shade of";
+}
+function ownerWords(entry, whose) {
+	return entry.hex === entry.asked ? `${whose} on ${entry.slot.name}` : `${shadeWords(entry.asked, entry.hex)} ${whose} on ${entry.slot.name}`;
+}
+const isGiltEnd = (spec, role) => spec.roles[role].giltEnd === true;
+/** Two owner colours this close count as one. */
+const SAME_COLOUR = .05;
+/** Palettes for the same look keep at least this OKLab ΔE apart on one of their coloured parts. */
+const OWN_PALETTE_MIN_DIFFERENCE = .06;
+const colouredRoles = [
+	"primary",
+	"secondary",
+	"accent",
+	"muted"
+];
+/** How far apart two palettes are on the parts that carry colour. */
+function paletteDifference(a, b) {
+	return Math.max(...colouredRoles.map((role) => colourDistance(a[role], b[role])));
+}
+function slotFor(spec, role) {
+	return spec.slots.find((entry) => entry.roles.includes(role)) ?? {
+		roles: [role],
+		name: spec.roles[role].name
+	};
+}
+function placementsOf(painted) {
+	const owned = painted.held.flatMap((entry) => entry.source === "made" ? [] : [{
+		colour: entry.source,
+		role: entry.role,
+		place: entry.slot.name,
+		drawn: entry.hex === entry.asked ? { kind: "exact" } : {
+			kind: "nearest-shade",
+			hex: entry.hex,
+			deltaE: entry.deltaE
+		}
+	}]);
+	const [first, ...rest] = owned;
+	return first ? [first, ...rest] : null;
+}
+function offered(painted, palette, admit) {
+	return admit(painted) ? {
+		kind: "offered",
+		painted,
+		palette
+	} : {
+		kind: "unfit",
+		reason: { kind: "buttons-replaced" }
+	};
+}
+/** The cheapest offered candidate, or the first reason none was. */
+function bestOffered(candidates) {
+	const offers = candidates.flatMap((candidate$1) => candidate$1.kind === "offered" ? [candidate$1] : []);
+	const best = offers.reduce((chosen, next) => !chosen || next.painted.cost < chosen.painted.cost ? next : chosen, undefined);
+	return best ?? candidates.find((candidate$1) => candidate$1.kind === "unfit") ?? {
+		kind: "unfit",
+		reason: { kind: "buttons-replaced" }
+	};
+}
+function singleCandidate(spec, first, slot, admit) {
+	const painted = paintPalette(spec, {
+		lead: first,
+		holds: [{
+			source: "first",
+			hex: first,
+			slot
+		}]
+	});
+	if (painted.kind === "unfit") return painted;
+	const lead = painted.held[0];
+	const placements = placementsOf(painted);
+	if (!lead || !placements) return {
+		kind: "unfit",
+		reason: {
+			kind: "role-unmet",
+			role: slot.roles[0]
+		}
+	};
+	const mentions = spec.order.filter((role) => role !== lead.role && spec.roles[role].mention && !(isGiltEnd(spec, lead.role) && isGiltEnd(spec, role))).map((role) => `${spec.roles[role].name} in ${shadeWords(first, painted.colors[role])} it`);
+	const describe = sentence(`${ownerWords(lead, "your colour")}${mentions.length ? `, with ${mentions.join(" and ")}` : ""}`);
+	return offered(painted, {
+		kind: "single",
+		colors: painted.colors,
+		mode: painted.mode,
+		describe,
+		placements,
+		made: null
+	}, admit);
+}
+/** The owner's colour alone, in the place it suits best of those the look keeps its buttons in. */
+function singlePalette(spec, first, admit) {
+	return bestOffered(spec.slots.map((slot) => singleCandidate(spec, first, slot, admit)));
+}
+/** Where the second colour shows, in words: the owner's is "your second colour", a made one is named. */
+function secondWords(spec, rule$1, painted, placed, whose) {
+	if (isGiltEnd(spec, placed.role)) {
+		return `gilt buttons running from ${colourName(painted.colors.accent)} into ${colourName(painted.colors.primary)}`;
+	}
+	const name = placed.source !== "made" ? placed.hex === placed.asked ? whose : `${shadeWords(placed.asked, placed.hex)} ${whose}` : colourName(placed.hex);
+	return `${name} on ${placed.slot.name}${rule$1.alsoTints ? ` and ${rule$1.alsoTints.name}` : ""}`;
+}
+function withSecond(spec, rule$1, first, second, admit) {
+	const holds = [{
+		source: "first",
+		hex: first,
+		slot: slotFor(spec, rule$1.lead)
+	}, {
+		source: second.source,
+		hex: second.hex,
+		slot: slotFor(spec, rule$1.second)
+	}];
+	const hueSources = Object.fromEntries((rule$1.alsoTints?.roles ?? []).map((role) => [role, second.hex]));
+	const painted = paintPalette(spec, {
+		lead: first,
+		holds,
+		hueSources
+	});
+	if (painted.kind === "unfit") return painted;
+	const lead = painted.held.find((entry) => entry.source === "first");
+	const placedSecond = painted.held.find((entry) => entry.source === second.source);
+	const placements = placementsOf(painted);
+	if (!lead || !placedSecond || !placements) return {
+		kind: "unfit",
+		reason: {
+			kind: "role-unmet",
+			role: rule$1.second
+		}
+	};
+	const owner = second.source === "second";
+	const describe = sentence(`${ownerWords(lead, owner ? "your first colour" : "your colour")}, with ${secondWords(spec, rule$1, painted, placedSecond, "your second colour")}`);
+	const body = {
+		colors: painted.colors,
+		mode: painted.mode,
+		describe,
+		placements
+	};
+	return offered(painted, owner ? {
+		...body,
+		kind: "owner-contrast",
+		made: null
+	} : {
+		...body,
+		kind: "made-contrast",
+		made: {
+			rule: rule$1.label,
+			hex: placedSecond.hex,
+			role: placedSecond.role,
+			place: placedSecond.slot.name
+		}
+	}, admit);
+}
+const differenceFrom = (before, palette) => Math.min(...before.map((other) => paletteDifference(other.colors, palette.colors)));
+/**
+* The rule's contrast: its best hue whose palette the look can offer and
+* that looks visibly different from the palettes before it, otherwise the
+* offered one that differs most. Unfit only when no hue gives an offered palette.
+*/
+function madeContrast(spec, rule$1, first, avoidHue, before, admit) {
+	const offers = [];
+	const failures = [];
+	for (const hue of candidateHues(rule$1, lchOf(first).h, avoidHue).flat()) {
+		const candidate$1 = withSecond(spec, rule$1, first, {
+			source: "made",
+			hex: madeColour(rule$1, first, hue)
+		}, admit);
+		if (candidate$1.kind === "unfit") {
+			failures.push(candidate$1.reason);
+			continue;
+		}
+		const offer = {
+			palette: candidate$1.palette,
+			hue: lchOf(candidate$1.palette.made?.hex ?? first).h,
+			difference: differenceFrom(before, candidate$1.palette)
+		};
+		if (offer.difference >= OWN_PALETTE_MIN_DIFFERENCE) return offer;
+		offers.push(offer);
+	}
+	const best = offers.reduce((chosen, next) => !chosen || next.difference > chosen.difference ? next : chosen, undefined);
+	if (best) return best;
+	return {
+		kind: "unfit",
+		reason: failures[0] ?? { kind: "buttons-replaced" }
+	};
+}
+/**
+* The owner's own second colour as palette 2, in whichever of the look's two
+* contrast places needs it moved least among those that look visibly
+* different from the single-colour palette. Null when neither does.
+*/
+function ownerContrastFor(spec, first, second, single, admit) {
+	const distinct$1 = spec.contrast.map((rule$1) => withSecond(spec, rule$1, first, {
+		source: "second",
+		hex: second
+	}, admit)).filter((candidate$1) => candidate$1.kind === "offered" && paletteDifference(candidate$1.palette.colors, single.colors) >= OWN_PALETTE_MIN_DIFFERENCE);
+	const chosen = bestOffered(distinct$1);
+	return chosen.kind === "offered" ? chosen.palette : null;
+}
+const isMade = (result) => "palette" in result;
+/**
+* Three palettes for a booking look from one or two owner colours (fewer only
+* when the first colour has no hue to make a contrast from). `admit` is the
+* surface owner's decision on whether the look keeps its own buttons; see
+* `bookingLookButtonAdmission`. Deterministic, so a stored palette can be
+* matched back to the palette it came from.
+*/
+function ownColourPalettes(spec, colours, admit) {
+	const [first, maybeSecond] = colours;
+	const tooAlike = maybeSecond !== undefined && colourDistance(first, maybeSecond) < SAME_COLOUR;
+	const second = tooAlike ? undefined : maybeSecond;
+	const singleResult = singlePalette(spec, first, admit);
+	if (singleResult.kind === "unfit") return singleResult;
+	const single = singleResult.palette;
+	const ownerContrast = second ? ownerContrastFor(spec, first, second, single, admit) : null;
+	if (lchOf(first).c < ACHROMATIC_CHROMA) {
+		return {
+			kind: "fewer",
+			palettes: ownerContrast ? [single, ownerContrast] : [single],
+			reason: "no-hue"
+		};
+	}
+	if (second && ownerContrast) return withOwnerContrast(spec, first, second, single, ownerContrast, admit);
+	return withMadeContrasts(spec, first, single, maybeSecond === undefined ? "none" : "too-alike", admit);
+}
+function withOwnerContrast(spec, first, second, single, ownerContrast, admit) {
+	const made = madeContrast(spec, spec.contrast[0], first, lchOf(second).h, [single, ownerContrast], admit);
+	if (!isMade(made)) return made;
+	return {
+		kind: "three",
+		palettes: [
+			single,
+			ownerContrast,
+			made.palette
+		],
+		secondColour: "used"
+	};
+}
+/** Both of the look's made contrasts. A second colour given but not used was too close to the first, or to the single-colour palette. */
+function withMadeContrasts(spec, first, single, secondColour, admit) {
+	const [ruleA, ruleB] = spec.contrast;
+	const a = madeContrast(spec, ruleA, first, null, [single], admit);
+	if (!isMade(a)) return a;
+	const b = madeContrast(spec, ruleB, first, a.hue, [single, a.palette], admit);
+	if (!isMade(b)) return b;
+	return {
+		kind: "three",
+		palettes: [
+			single,
+			a.palette,
+			b.palette
+		],
+		secondColour
+	};
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/ownColours/bookingLookButtonAdmission.ts
+/**
+* Where each look's most prominent buttons sit on a booking page, per the
+* surface table (apps/frontend hostedBookingSurfaceTable.test.ts): the
+* opening, and the offerings section's cards or section.
+*/
+const bookingLookProminentButtonSurfaces = {
+	"site-style:fulcrum": ["base", "sheet"],
+	"site-style:folio": ["base", "sheet"],
+	"site-style:measure": ["base", "base"],
+	"site-style:grounded-practice": ["band", "base"],
+	"site-style:lantern": ["base", "band"],
+	"site-style:poster": ["brand", "sheet"]
+};
+/** Grounded Practice's legacy sections carry only resolved styles: the look's button fills from a palette token. */
+function legacyKeepsButton(theme, surface$1) {
+	const color = surface$1 === "band" ? "muted" : "background";
+	const resolved = resolveSurface({
+		kind: "section",
+		background: {
+			type: "color",
+			color
+		}
+	}, opaqueSurfaceContextFromTheme(theme));
+	const styles = resolved.buttonStyles;
+	return `${styles["--rb-action-primary-base-background-color"] ?? ""}${styles["--rb-action-primary-base-background-image"] ?? ""}`.includes("var(--tb-");
+}
+function keptPrimary(primary) {
+	return primary?.kind === "preferred" || primary?.kind === "repaired" && primary.candidate === "contextual-hover";
+}
+/**
+* Whether the surface owner keeps the look's own primary button on this
+* surface, in every state, rather than replacing it with an outline.
+*/
+function keepsLookButton(style, theme, surface$1) {
+	if (style.looks.kind !== "offers") return legacyKeepsButton(theme, surface$1);
+	const declared = style.looks.surfaces[surface$1];
+	if (declared?.kind !== "token") return false;
+	const resolved = resolveSurface({
+		kind: "token",
+		token: declared.token,
+		...declared.buttonContext ? { buttonContext: declared.buttonContext } : {},
+		...declared.foreground ? { foreground: declared.foreground } : {}
+	}, opaqueSurfaceContextFromTheme(theme));
+	return keptPrimary(resolved.buttonContext.roles?.primary);
+}
+/** The look's theme with this palette, compiled as a booking page would be. */
+function bookingLookThemeFor(style, palette) {
+	return compileReplacementSiteThemeFromSelections({
+		siteStyle: style,
+		palette: {
+			colors: Object.entries(palette.colors).map(([name, hex$1]) => ({
+				name,
+				hex: hex$1
+			})),
+			meta: { mode: palette.mode }
+		},
+		compilationPlan: replaceSiteStyleCompilationPlan({
+			headerSelection: defaultHeaderSelectionForSiteStyle(style),
+			buttonStyleSelection: null
+		})
+	}).theme;
+}
+/** The surface owner's decision, for one booking look, on whether a palette keeps the look's buttons where they matter most. */
+function bookingLookButtonAdmission(lookId) {
+	const style = getCuratedSiteStyle(asSiteStyleId(lookId));
+	if (!style) throw new Error(`Missing booking look ${lookId}`);
+	return (palette) => {
+		const theme = bookingLookThemeFor(style, palette);
+		return bookingLookProminentButtonSurfaces[lookId].every((surface$1) => keepsLookButton(style, theme, surface$1));
+	};
+}
+/** A booking look's own-colour palettes, admitted through the surface owner. */
+function bookingLookOwnColourPalettes(lookId, colours) {
+	return ownColourPalettes(bookingLookColourSpecs[lookId], colours, bookingLookButtonAdmission(lookId));
+}
+
 //#endregion
 //#region ../site-commands/src/application.ts
 const commandEffectKinds = [
@@ -44095,174 +46122,6 @@ function generateCssVars(palette) {
 	return cssVars;
 }
 
-//#endregion
-//#region ../theme-core/src/palette/family.ts
-/**
-* Only `colourFamily` makes one (the class is not exported), so a caller can't
-* swap in its own members and still hand the solver a valid family. That
-* matters because `unpaintable` relies on the members running from black to
-* white.
-*/
-var Family = class {
-	#members;
-	constructor(seed, members) {
-		this.seed = seed;
-		this.#members = Object.freeze(members);
-	}
-	/** Unique by hex, ascending luminance. Includes the exact seed, black and white. */
-	get members() {
-		return this.#members;
-	}
-};
-/** Lightness steps between black and white. */
-const FAMILY_STEPS = 512;
-const GAMUT_BISECTION_STEPS = 18;
-/** The highest chroma at or below `c` that stays inside sRGB at this lightness and hue. */
-function gamutChroma(l, c, h) {
-	if (inLinearSrgbGamut(oklchToLinearSrgb(l, c, h))) return c;
-	return Array.from({ length: GAMUT_BISECTION_STEPS }).reduce(({ lo, hi }) => {
-		const mid = (lo + hi) / 2;
-		return inLinearSrgbGamut(oklchToLinearSrgb(l, mid, h)) ? {
-			lo: mid,
-			hi
-		} : {
-			lo,
-			hi: mid
-		};
-	}, {
-		lo: 0,
-		hi: c
-	}).lo;
-}
-function oklabDistance(a, b) {
-	return Math.hypot(a.L - b.L, a.a - b.a, a.b - b.b);
-}
-function colourFamily(seedHex) {
-	if (!/^#[0-9a-f]{6}$/i.test(seedHex)) throw new Error(`Expected an opaque #rrggbb colour: ${seedHex}`);
-	const features = featuresFromHex(seedHex.toLowerCase());
-	const seed = member(seedHex.toLowerCase(), {
-		l: features.okL,
-		c: features.okC,
-		h: features.okH
-	});
-	const seedTaper = Math.max(.001, Math.sin(Math.PI * seed.sample.l));
-	const samples = Array.from({ length: FAMILY_STEPS + 1 }, (_, i) => {
-		const l = i / FAMILY_STEPS;
-		const c = gamutChroma(l, seed.sample.c * Math.min(1, Math.sin(Math.PI * l) / seedTaper), seed.sample.h);
-		return sampleMember({
-			l,
-			c,
-			h: seed.sample.h
-		});
-	});
-	const unique = new Map([seed, ...samples].map((candidate$1) => [candidate$1.hex, candidate$1]).reverse());
-	const members = [...unique.values()].sort((a, b) => a.y - b.y || (a.hex < b.hex ? -1 : a.hex > b.hex ? 1 : 0));
-	return new Family(seed, members);
-}
-function sampleMember(sample) {
-	const { r, g, b } = oklchToLinearSrgb(sample.l, sample.c, sample.h);
-	return member(rgbToHex(linearToSrgb(r), linearToSrgb(g), linearToSrgb(b)), sample);
-}
-function member(hex, sample) {
-	const { r, g, b } = hexToRgb(hex);
-	return {
-		hex,
-		y: hexLuminance(hex),
-		oklab: srgbToOklab(r, g, b),
-		sample
-	};
-}
-
-//#endregion
-//#region ../theme-core/src/palette/utils/inkSolver.ts
-/**
-* How far (OKLab ΔE) a brand colour drawn as ink may be nudged along its own
-* family before it stops reading as that colour. Past this the caller uses
-* neutral or palette text instead (Will, 2026-10-14).
-*/
-const BRAND_INK_MAX_DELTA_E = .08;
-/**
-* The seed itself when it clears `paint`, otherwise the family member nearest
-* the seed (OKLab ΔE) that clears. On a light ground that is darker, on a dark
-* one lighter. A passing member further than `maxDistance` from the seed is
-* refused as `too-far`, which is distinct from `unpaintable`: the family runs
-* from black to white, so if no member clears, neither does black or white.
-*/
-function inkFrom(family, paint, ratio$1, maxDistance = BRAND_INK_MAX_DELTA_E) {
-	assertContrastRatio(ratio$1);
-	if (!Number.isFinite(maxDistance) || maxDistance < 0) {
-		throw new RangeError(`Maximum ink distance must be finite and not negative: ${maxDistance}`);
-	}
-	const seedRatio = worstContrast(family.seed.y, paint);
-	if (seedRatio >= ratio$1) return {
-		kind: "ink",
-		hex: family.seed.hex,
-		ratio: seedRatio,
-		source: "exact"
-	};
-	const nearest = family.members.reduce((best, member$1) => {
-		const achieved = worstContrast(member$1.y, paint);
-		if (achieved < ratio$1) return best;
-		const distance$1 = oklabDistance(member$1.oklab, family.seed.oklab);
-		return best === null || distance$1 < best.distance ? {
-			hex: member$1.hex,
-			distance: distance$1,
-			ratio: achieved
-		} : best;
-	}, null);
-	if (nearest === null) return {
-		kind: "unpaintable",
-		interval: paint,
-		ratio: ratio$1
-	};
-	if (nearest.distance > maxDistance) {
-		return {
-			kind: "too-far",
-			nearest: {
-				hex: nearest.hex,
-				distance: nearest.distance
-			},
-			maxDistance
-		};
-	}
-	return {
-		kind: "ink",
-		hex: nearest.hex,
-		ratio: nearest.ratio,
-		source: "family"
-	};
-}
-/**
-* Neutral text for a paint. The style's preferred neutral wins when one of its
-* pair clears (the higher-contrast one, dark on a tie); otherwise literal black
-* or white by `maxContrastBlackOrWhite`; otherwise `unpaintable`.
-*/
-function neutralInk(paint, ratio$1, preferred) {
-	assertContrastRatio(ratio$1);
-	if (preferred) {
-		const dark = worstContrast(hexLuminance(preferred.dark), paint);
-		const light = worstContrast(hexLuminance(preferred.light), paint);
-		const [hex, achieved] = dark >= light ? [preferred.dark, dark] : [preferred.light, light];
-		if (achieved >= ratio$1) return {
-			kind: "ink",
-			hex,
-			ratio: achieved,
-			source: "neutral"
-		};
-	}
-	const literal = maxContrastBlackOrWhite(paint);
-	return literal.ratio >= ratio$1 ? {
-		kind: "ink",
-		hex: literal.ink === "black" ? "#000000" : "#ffffff",
-		ratio: literal.ratio,
-		source: "neutral"
-	} : {
-		kind: "unpaintable",
-		interval: paint,
-		ratio: ratio$1
-	};
-}
-
 //#endregion
 //#region ../theme-core/src/palette/utils/backgroundGeneration.ts
 /**
@@ -44757,7 +46616,7 @@ const allRecipes = [
 //#region ../theme-core/src/palette/utils/legs.ts
 const clamp01$1 = (x) => Math.max(0, Math.min(1, x));
 function nudgeToneForContrast(color, againstHex, target, prefer) {
-	const steps = [
+	const steps$1 = [
 		0,
 		.02,
 		.04,
@@ -44772,18 +46631,18 @@ function nudgeToneForContrast(color, againstHex, target, prefer) {
 		L: color.L
 	};
 	let bestMiss = Infinity;
-	for (const dir of dirs) for (const s of steps) {
+	for (const dir of dirs) for (const s of steps$1) {
 		const L = clamp01$1(color.L + dir * s);
-		const hex = oklchToHexGamut(L, color.C, color.h);
-		const cr = contrastRatio(hex, againstHex);
+		const hex$1 = oklchToHexGamut(L, color.C, color.h);
+		const cr = contrastRatio(hex$1, againstHex);
 		const miss = Math.max(0, target - cr);
 		if (miss === 0) return {
-			hex,
+			hex: hex$1,
 			L
 		};
 		if (miss < bestMiss) {
 			best = {
-				hex,
+				hex: hex$1,
 				L
 			};
 			bestMiss = miss;
@@ -44791,8 +46650,8 @@ function nudgeToneForContrast(color, againstHex, target, prefer) {
 	}
 	return best;
 }
-function oklchFromHex(hex) {
-	const f = featuresFromHex(hex);
+function oklchFromHex(hex$1) {
+	const f = featuresFromHex(hex$1);
 	return {
 		L: f.okL,
 		C: f.okC,
@@ -44816,16 +46675,16 @@ function ensureHueLeg(primaryHex, legs, targetL, targetCmid, backgroundHex, pref
 		const L = targetL;
 		const C = targetCmid;
 		const h = wrapDeg(p.h + offset);
-		let hex = oklchToHexGamut(L, C, h);
-		hex = nudgeToneForContrast({
+		let hex$1 = oklchToHexGamut(L, C, h);
+		hex$1 = nudgeToneForContrast({
 			L,
 			C,
 			h
 		}, backgroundHex, 3, prefer).hex;
-		const a = oklchFromHex(hex);
-		const score = .7 * dOKLCH(a, p) + .3 * (contrastRatio(hex, backgroundHex) / 7);
+		const a = oklchFromHex(hex$1);
+		const score = .7 * dOKLCH(a, p) + .3 * (contrastRatio(hex$1, backgroundHex) / 7);
 		return {
-			hex,
+			hex: hex$1,
 			h,
 			score
 		};
@@ -44897,12 +46756,12 @@ function generateSupportRole(targetHue, theme, labels, backgroundHex, avoidHexes
 	}
 	const preferDir = theme === "dark" ? "lighter" : "darker";
 	const _hex0 = oklchToHexGamut(Ltarget, Cmid, h);
-	const { hex } = nudgeToneForContrast({
+	const { hex: hex$1 } = nudgeToneForContrast({
 		L: Ltarget,
 		C: Cmid,
 		h
 	}, backgroundHex, 3, preferDir);
-	return hex;
+	return hex$1;
 }
 
 //#endregion
@@ -44930,18 +46789,18 @@ function legibleTextOn(bgHex, _prefer, min = 4.5, opts) {
 	const startL = bgIsLight ? .14 : .97;
 	const preferDir = bgIsLight ? "darker" : "lighter";
 	const target = Math.max(3, min + cushion);
-	const { hex } = nudgeToneForContrast({
+	const { hex: hex$1 } = nudgeToneForContrast({
 		L: startL,
 		C,
 		h: neutralH
 	}, bgHex, target, preferDir);
-	const test = contrastRatio(hex, bgHex);
+	const test = contrastRatio(hex$1, bgHex);
 	if (test >= min) {
 		const Lclip = (L) => {
 			if (bgIsLight) return Math.max(.1, Math.min(.3, L));
 			return Math.max(.85, Math.min(.98, L));
 		};
-		const f = featuresFromHex(hex);
+		const f = featuresFromHex(hex$1);
 		return oklchToHexGamut(Lclip(f.okL), C, neutralH);
 	}
 	return bgIsLight ? "#000000" : "#FFFFFF";
@@ -45287,16 +47146,16 @@ const RULES = [
 		}
 	}
 ];
-function classifyColor(hex, rules = RULES) {
-	const f = featuresFromHex(hex);
+function classifyColor(hex$1, rules = RULES) {
+	const f = featuresFromHex(hex$1);
 	const labels = rules.map((r) => ({
 		label: r.label,
 		score: clamp01(r.score(f))
 	})).filter((x) => x.score > 0).sort((a, b) => b.score - a.score);
 	return labels;
 }
-function topLabel(hex, rules = RULES) {
-	const list = classifyColor(hex, rules);
+function topLabel(hex$1, rules = RULES) {
+	const list = classifyColor(hex$1, rules);
 	return list[0] ?? null;
 }
 
@@ -45382,8 +47241,8 @@ function suggestRecipes(labels, fallback = [
 	const ranked = Array.from(scores.entries()).sort((a, b) => b[1] - a[1]).map(([id$2]) => id$2);
 	return ranked.length ? ranked : fallback;
 }
-function generateAllPalettes(hex, _labels) {
-	return allRecipes.map((recipe) => buildPaletteRespectingSeed(recipe, featuresFromHex(hex), hex));
+function generateAllPalettes(hex$1, _labels) {
+	return allRecipes.map((recipe) => buildPaletteRespectingSeed(recipe, featuresFromHex(hex$1), hex$1));
 }
 function paletteToRecord(p) {
 	const out = {
@@ -45400,10 +47259,10 @@ function paletteToRecord(p) {
 	}
 	return out;
 }
-function ensureMinContrast(hex, bg, min = 2.5) {
-	let cr = contrastRatio(hex, bg);
-	if (cr >= min) return hex;
-	const f = featuresFromHex(hex);
+function ensureMinContrast(hex$1, bg, min = 2.5) {
+	let cr = contrastRatio(hex$1, bg);
+	if (cr >= min) return hex$1;
+	const f = featuresFromHex(hex$1);
 	const bgL = featuresFromHex(bg).okL;
 	let L = f.okL;
 	const dir = bgL >= .5 ? -1 : 1;
@@ -45413,10 +47272,10 @@ function ensureMinContrast(hex, bg, min = 2.5) {
 		const ncr = contrastRatio(cand, bg);
 		if (ncr > cr) {
 			cr = ncr;
-			hex = cand;
+			hex$1 = cand;
 		}
 	}
-	return hex;
+	return hex$1;
 }
 function blendOKLCH(a, b, alpha = .25) {
 	const A = featuresFromHex(a), B = featuresFromHex(b);
@@ -47038,13 +48897,13 @@ var require_jsx_runtime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../theme-core/src/mock-themes/components/swatch.tsx
 var import_jsx_runtime = /* @__PURE__ */ __toESM(require_jsx_runtime());
-function Swatch({ name, hex }) {
+function Swatch({ name, hex: hex$1 }) {
 	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
 		className: "rb-rounded-xl rb-overflow-hidden rb-shadow-sm rb-border",
 		style: { borderColor: "rgba(0, 0, 0, 0.05)" },
 		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
 			className: "rb-h-12",
-			style: { backgroundColor: hex }
+			style: { backgroundColor: hex$1 }
 		}), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
 			className: "rb-px-3 rb-py-2 rb-text-xs rb-flex rb-items-center rb-justify-between",
 			children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
@@ -47054,7 +48913,7 @@ function Swatch({ name, hex }) {
 			}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
 				className: "rb-font-mono",
 				style: { color: "#71717a" },
-				children: hex
+				children: hex$1
 			})]
 		})]
 	});
@@ -47646,8 +49505,8 @@ const ordinaryEventDashboard = [{
 	surface: "Dashboard",
 	scope: "Events booked by date"
 }];
-const meaning = (label, description) => ({
-	label,
+const meaning = (label$1, description) => ({
+	label: label$1,
 	description,
 	availability: ordinaryEventDashboard
 });
@@ -51407,4 +53266,4 @@ function parseSdkEventRunUpsertInput(input, runIndex, options) {
 }
 
 //#endregion
-export { createFormRef as $, deriveVideoSlotPolicy as $n, resolveTokenOrCssColorValue as $r, asFooterLookId as $t, getSiteCommandMetadata as A, deleteEnvSpecificKeys as An, makeBoundaryId as Ar, generateHeaderScrollTreatmentStyles as At, eventBookingOfferIntentSchema as B, isSiteScopedDirectImageStoragePath as Bn, surfaceDecorationColors as Br, getComponentBorderWidthPx as Bt, sortRecord as C, boxBackgroundSchema as Cn, defineFrameCapability as Cr, deriveSiteStyleBlockPolicy as Ct, mapEventCommandContent as D, collectPortableMediaReferencesFromContent as Dn, featureCardCompositionTreatmentValues as Dr, getGradientPreset as Dt, parseAndPlanCommandBatchForTypes as E, stripStaleTransitionStyleGroup as En, eyebrowTreatmentValues as Er, gradientToCss as Et, pageIdentifierForBlockCommand as F, parseAspectRatioValue as Fn, visibleHeadingDecorationFamilyValues as Fr, BREAKPOINT_MD as Ft, ianaTimezoneSchema as G, resolveManagedMediaReference as Gn, mergeStyles as Gr, themeButtonExtraClassesWithTrailingIcon as Gt, bookingPaymentTermsSchema as H, persistableMediaSchema as Hn, TokenResolver as Hr, ICON_CONFIG as Ht, pageIdentifierForCommand as I, resolveMediaTransformForAspect as In, parseResolvedSurface as Ir, BREAKPOINT_SM as It, createCommandRef as J, buildMediaIdentifierFromFilename as Jn, mapDrawingStyle as Jr, parseThemeForPersistence as Jt, createBlockRef as K, mediaTypeDiscriminants as Kn, rgbColorValue as Kr, themeButtonSizeClassName as Kt, pagePathForCommand as L, getDirectImageUrlForRelativePath as Ln, parseSurfaceTree as Lr, BREAKPOINT_XL as Lt, blockIdentifierForCommand as M, rotateNormalizedPoint as Mn, testimonialsCompositionTreatmentValues as Mr, getHeaderPaintTargets as Mt, blockOrderIdentifiersForCommand as N, normalizeWidthCandidates as Nn, tileTreatmentValues as Nr, renderHeaderPaintTargetRules as Nt, evaluateSiteCommandBatchExposure as O, summarizePortableMediaReferences as On, headingDecorationColorTokenValues as Or, parseGradientPresetId as Ot, entryIdentifierForCommand as P, isExplicitRectCrop as Pn, toNonEmptyReadonlyArray as Pr, BREAKPOINT_LG as Pt, createFooterRef as Q, slugifyMediaIdentifier as Qn, resolveThemeColorReferenceValue as Qr, normalizeCardRole as Qt, hasConfiguredBookingVertical as R, getDirectImageUrlForSiteScopedPath as Rn, resolveSurface as Rr, MQ_MD_DOWN as Rt, venueManagementFields as S, boxBackgroundOverlaySchema as Sn, defineBlockDesignCapability as Sr, resolvePublishedLook as St, createDryRunReport as T, siteChromeBackgroundOverrideOwner as Tn, eventListTreatmentValues as Tr, compiledRuntimeStyleFieldNames as Tt, require_jsx_runtime as U, runtimeMediaSchema as Un, backgroundColorStyle as Ur, generateDefaultButtonSystem as Ut, bookingPaymentCollectionOptionSchema as V, mediaSchema as Vn, resolveSurfaceForeground as Vr, getComponentShadowVar as Vt, require_react as W, buildRenderableMediaAssetIndex as Wn, borderColorStyle as Wr, parseThemeButtonVariantId as Wt, createEventCategoryRef as X, parseMediaIdentifier as Xn, isCssColorLiteral as Xr, cardRoleSchema as Xt, createContentEntryRef as Y, parseCanonicalMediaIdentifier as Yn, opaqueSurfaceDeclarations as Yr, renderCssDeclarations as Yt, createEventSeriesRef as Z, resolveMediaIdentifier as Zn, resolveOnColorForThemeToken as Zr, cardVariantRoleValues as Zt, normalizeLinkValue as _, heroPhotoPaintsGround as _n, asDesignBlockId as _r, resolveLookSlotSurfaces as _t, classifySdkEventSchedule as a, surfaceForegroundInputFromResolved as ai, buttonStyleSelectionSchema as an, parseRelativeStoragePath as ar, slugPart as at, isEventVisibility as b, resolveSectionPhotoPlacement as bn, asSiteStyleId as br, resolveEffectiveArrangement as bt, customLinkSchema as c, expandPalette as ci, generateNavLinkCSS as cn, classifyKnownMimeType as cr, headerLeafTextColor as ct, internalLinkSchema as d, parseBlockColorToken as di, footerPreferencesSchema as dn, defineBlockDesignMetadata as dr, headerPreferencesSchema as dt, PUBLIC_BUTTON_ROLES as ei, footerLookIdValues as en, resolveVideoSelectionIntentForMediaField as er, createNavigationRef as et, internalResolvedLinkSchema as f, __commonJSMin as fi, headerRootPaint as fn, resolveEffectiveKnobs as fr, mergeHeaderNavTypographyPreference as ft, linkSchema as g, deriveSectionGround as gn, asAppearancePresetId as gr, resolveItemSurface as gt, isResolvedInternalLinkEntityType as h, sectionFactsForContent as hn, arrangementModes as hr, arrangementSlotNames as ht, sdkEventUpsertOptionalFieldSchemas as i, surfaceForegroundDeclarations as ii, headerStyleIdValues as in, normalizeAmbiguousStoragePathForSite as ir, refSlug as it, eventManagementTiming as j, looksLikeUuid as jn, offeringsPreviewCompositionTreatmentValues as jr, generateMobileOverlayBackdropFilterFix as jt, evaluateSiteCommandExposure as k, walkAndCollectImageAttrs as kn, introCompositionTreatmentValues as kr, themeSchema as kt, entryLinkSchema as l, getTextColorForBackground as li, pageDesignBoundaryTreatmentSchema as ln, managementMediaLibraryUploadLimitForMimeType as lr, transparentHeaderForegroundInput as lt, isInternalResolvedLinkValue as m, composeBoundary as mn, cardListKnobBlocks as mr, arrangementLookHooks as mt, sdkCourseBookingSettingsSchema as n, surfaceToneFromForegroundToken as ni, asHeaderStyleId as nn, getMimeType as nr, createSiteCommandSiteRef as nt, classifySdkEventBookingOffer as o, surfaceForegroundStyle as oi, footerForegroundCandidates as on, FILE_SIZE_LIMITS as or, effectiveHeaderNavLinkStyle as ot, internalRouteOnlyLinkSchema as p, __toESM as pi, boundaryLayout as pn, cardListFamilyBlocks as pr, readHeaderNavFontSizePreference as pt, createBlocksRef as q, mediaIdentifierSchema as qn, textColorStyle as qr, themeButtonVariantClassNames as qt, sdkEventOccurrenceInputSchema as r, defaultThemeTokens as ri, headerLayoutIdValues as rn, asRecord as rr, createVenueRef as rt, RESOLVED_INTERNAL_LINK_ENTITY_TYPES as s, surfaceForegroundValue as si, buildTextContrastShadow as sn, MAX_MANAGEMENT_MEDIA_UPLOAD_BYTES as sr, headerForegroundCandidates as st, classifySdkEventTiming as t, selectLogoVariant as ti, asHeaderLayoutId as tn, getExtensionForMimeType as tr, createPageRef as tt, externalLinkSchema as u, parseThemeColorToken as ui, pageDesignIntentSchemaVersion as un, parseSafeDownloadFilename as ur, readOpeningForegroundProjection as ut, pageLinkSchema as v, parseCanonicalRuntimeBackground as vn, asLayoutVariantKey as vr, arrangementManifestFromVariants as vt, stableStringify as w, runtimeBoxBackgroundSchema as wn, defineNoBlockDesignCapability as wr, requireCuratedSiteStyle as wt, resolvePageUpsertSeo as x, sectionForegroundBackground as xn, assertNever$1 as xr, resolveModeArrangement as xt, eventVisibilitySchema as y, resolveSectionBackground as yn, asPageFlowPresetId as yr, readStoredMode as yt, eventCommandScheduleSchema as z, getImageUrl as zn, serializeSurfaceTree as zr, headerVariantValues as zt };
+export { createFormRef as $, slugifyMediaIdentifier as $n, mapDrawingStyle as $r, asFooterLookId as $t, getSiteCommandMetadata as A, walkAndCollectImageAttrs as An, introCompositionTreatmentValues as Ar, generateHeaderScrollTreatmentStyles as At, eventBookingOfferIntentSchema as B, getImageUrl as Bn, serializeSurfaceTree as Br, getComponentBorderWidthPx as Bt, sortRecord as C, boxBackgroundOverlaySchema as Cn, defineBlockDesignCapability as Cr, deriveSiteStyleBlockPolicy as Ct, mapEventCommandContent as D, stripStaleTransitionStyleGroup as Dn, eyebrowTreatmentValues as Dr, getGradientPreset as Dt, parseAndPlanCommandBatchForTypes as E, siteChromeBackgroundOverrideOwner as En, eventListTreatmentValues as Er, gradientToCss as Et, pageIdentifierForBlockCommand as F, isExplicitRectCrop as Fn, toNonEmptyReadonlyArray as Fr, BREAKPOINT_MD as Ft, ianaTimezoneSchema as G, buildRenderableMediaAssetIndex as Gn, surfaceForegroundValue as Gr, themeButtonExtraClassesWithTrailingIcon as Gt, bookingPaymentTermsSchema as H, mediaSchema as Hn, surfaceForegroundDeclarations as Hr, ICON_CONFIG as Ht, pageIdentifierForCommand as I, parseAspectRatioValue as In, visibleHeadingDecorationFamilyValues as Ir, BREAKPOINT_SM as It, createCommandRef as J, mediaIdentifierSchema as Jn, backgroundColorStyle as Jr, parseThemeForPersistence as Jt, createBlockRef as K, resolveManagedMediaReference as Kn, surfaceInkDeclarations as Kr, themeButtonSizeClassName as Kt, pagePathForCommand as L, resolveMediaTransformForAspect as Ln, parseResolvedSurface as Lr, BREAKPOINT_XL as Lt, blockIdentifierForCommand as M, looksLikeUuid as Mn, offeringsPreviewCompositionTreatmentValues as Mr, getHeaderPaintTargets as Mt, blockOrderIdentifiersForCommand as N, rotateNormalizedPoint as Nn, testimonialsCompositionTreatmentValues as Nr, renderHeaderPaintTargetRules as Nt, evaluateSiteCommandBatchExposure as O, collectPortableMediaReferencesFromContent as On, featureCardCompositionTreatmentValues as Or, parseGradientPresetId as Ot, entryIdentifierForCommand as P, normalizeWidthCandidates as Pn, tileTreatmentValues as Pr, BREAKPOINT_LG as Pt, createFooterRef as Q, resolveMediaIdentifier as Qn, textColorStyle as Qr, normalizeCardRole as Qt, hasConfiguredBookingVertical as R, getDirectImageUrlForRelativePath as Rn, parseSurfaceTree as Rr, MQ_MD_DOWN as Rt, venueManagementFields as S, sectionForegroundBackground as Sn, assertNever$1 as Sr, resolvePublishedLook as St, createDryRunReport as T, runtimeBoxBackgroundSchema as Tn, defineNoBlockDesignCapability as Tr, compiledRuntimeStyleFieldNames as Tt, require_jsx_runtime as U, persistableMediaSchema as Un, surfaceForegroundInputFromResolved as Ur, generateDefaultButtonSystem as Ut, bookingPaymentCollectionOptionSchema as V, isSiteScopedDirectImageStoragePath as Vn, surfaceDecorationColors as Vr, getComponentShadowVar as Vt, require_react as W, runtimeMediaSchema as Wn, surfaceForegroundStyle as Wr, parseThemeButtonVariantId as Wt, createEventCategoryRef as X, parseCanonicalMediaIdentifier as Xn, mergeStyles as Xr, cardRoleSchema as Xt, createContentEntryRef as Y, buildMediaIdentifierFromFilename as Yn, borderColorStyle as Yr, renderCssDeclarations as Yt, createEventSeriesRef as Z, parseMediaIdentifier as Zn, rgbColorValue as Zr, cardVariantRoleValues as Zt, normalizeLinkValue as _, __toESM as _i, deriveSectionGround as _n, asAppearancePresetId as _r, resolveLookSlotSurfaces as _t, classifySdkEventSchedule as a, PUBLIC_BUTTON_ROLES as ai, buttonStyleSelectionSchema as an, normalizeAmbiguousStoragePathForSite as ar, slugPart as at, isEventVisibility as b, resolveSectionBackground as bn, asPageFlowPresetId as br, resolveEffectiveArrangement as bt, customLinkSchema as c, resolveSurfaceForeground as ci, generateNavLinkCSS as cn, MAX_MANAGEMENT_MEDIA_UPLOAD_BYTES as cr, headerLeafTextColor as ct, internalLinkSchema as d, defaultThemeTokens as di, footerPreferencesSchema as dn, parseSafeDownloadFilename as dr, headerPreferencesSchema as dt, opaqueSurfaceDeclarations as ei, footerLookIdValues as en, deriveVideoSlotPolicy as er, createNavigationRef as et, internalResolvedLinkSchema as f, expandPalette as fi, headerNeedsPhotoShade as fn, defineBlockDesignMetadata as fr, mergeHeaderNavTypographyPreference as ft, linkSchema as g, __commonJSMin as gi, sectionFactsForContent as gn, arrangementModes as gr, resolveItemSurface as gt, isResolvedInternalLinkEntityType as h, parseBlockColorToken as hi, composeBoundary as hn, cardListKnobBlocks as hr, arrangementSlotNames as ht, sdkEventUpsertOptionalFieldSchemas as i, resolveTokenOrCssColorValue as ii, headerStyleIdValues as in, asRecord as ir, refSlug as it, eventManagementTiming as j, deleteEnvSpecificKeys as jn, makeBoundaryId as jr, generateMobileOverlayBackdropFilterFix as jt, evaluateSiteCommandExposure as k, summarizePortableMediaReferences as kn, headingDecorationColorTokenValues as kr, themeSchema as kt, entryLinkSchema as l, surfaceInkPublication as li, pageDesignBoundaryTreatmentSchema as ln, classifyKnownMimeType as lr, transparentHeaderForegroundInput as lt, isInternalResolvedLinkValue as m, parseThemeColorToken as mi, boundaryLayout as mn, cardListFamilyBlocks as mr, arrangementLookHooks as mt, sdkCourseBookingSettingsSchema as n, resolveOnColorForThemeToken as ni, asHeaderStyleId as nn, getExtensionForMimeType as nr, createSiteCommandSiteRef as nt, classifySdkEventBookingOffer as o, selectLogoVariant as oi, footerForegroundCandidates as on, parseRelativeStoragePath as or, effectiveHeaderNavLinkStyle as ot, internalRouteOnlyLinkSchema as p, getTextColorForBackground as pi, headerRootPaint as pn, resolveEffectiveKnobs as pr, readHeaderNavFontSizePreference as pt, createBlocksRef as q, mediaTypeDiscriminants as qn, surfaceInkStyle as qr, themeButtonVariantClassNames as qt, sdkEventOccurrenceInputSchema as r, resolveThemeColorReferenceValue as ri, headerLayoutIdValues as rn, getMimeType as rr, createVenueRef as rt, RESOLVED_INTERNAL_LINK_ENTITY_TYPES as s, surfaceToneFromForegroundToken as si, buildTextContrastShadow as sn, FILE_SIZE_LIMITS as sr, headerForegroundCandidates as st, classifySdkEventTiming as t, isCssColorLiteral as ti, asHeaderLayoutId as tn, resolveVideoSelectionIntentForMediaField as tr, createPageRef as tt, externalLinkSchema as u, TokenResolver as ui, pageDesignIntentSchemaVersion as un, managementMediaLibraryUploadLimitForMimeType as ur, readOpeningForegroundProjection as ut, pageLinkSchema as v, heroPhotoPaintsGround as vn, asDesignBlockId as vr, arrangementManifestFromVariants as vt, stableStringify as w, boxBackgroundSchema as wn, defineFrameCapability as wr, requireCuratedSiteStyle as wt, resolvePageUpsertSeo as x, resolveSectionPhotoPlacement as xn, asSiteStyleId as xr, resolveModeArrangement as xt, eventVisibilitySchema as y, parseCanonicalRuntimeBackground as yn, asLayoutVariantKey as yr, readStoredMode as yt, eventCommandScheduleSchema as z, getDirectImageUrlForSiteScopedPath as zn, resolveSurface as zr, headerVariantValues as zt };