riverbankcms 0.4.3 → 0.5.0

package/dist/{style-J8_HbTIm.mjs → style-CeGQc8Oy.mjs}

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 import { At as ok, B as parseUtcIsoDateTimeString, Ct as unsafeAsSiteScopedStoragePath, D as mapNonEmptyArray, Dt as unsafeAsUploadSessionId, E as fromArray, Et as unsafeAsStoragePath, O as hasText, Ot as unsafeAsUserId, St as unsafeAsSiteId, Tt as unsafeAsStorageBucketName, Z as assertNever, _ as parseFooterCompositionV1, _t as unsafeAsPositiveByteCount, a as parseVerticalPresetId, at as unsafeAsBookingRequirementId, bt as unsafeAsSafeDownloadFilename, c as EVENT_PRESET_VALUES, dt as unsafeAsEventOfferingId, f as createSecret, ft as unsafeAsEventSeriesId, g as footerNavigationLayouts, gt as unsafeAsOriginalFilename, h as stableJsonStringify, ht as unsafeAsOccurrenceId, i as parseVerticalId, k as isPresent, kt as err, l as ORDINARY_EVENT_PRESET_VALUES, lt as unsafeAsDetectedMimeType, m as parseManagementKey, mt as unsafeAsMediaAssetId, n as canonicalizeConfiguredBookingVerticalConfig, nt as parseSiteId, o as resolveSiteVerticalBookingConfig, ot as unsafeAsBookingSessionId, p as exposeSecret, pt as unsafeAsFileChecksumSha256, st as unsafeAsDeclaredMimeType, ut as unsafeAsEntitlementId, vt as unsafeAsPositiveSeconds, w as isCanonicalRichTextDoc, xt as unsafeAsSiteFontId, yt as unsafeAsProductId } from "./src-DKm0bLEA.mjs";
 import { a as classifySdkEventPricing, n as sdkEventOccurrenceInputSchema, o as classifySdkEventPaymentTerms } from "./sdk-event-upsert-Dy08IXYL.mjs";
-import { t as CliSdkPeerError } from "./sdk-peer-CeNepTFW.mjs";
+import { t as CliSdkPeerError } from "./sdk-peer-sZF43pDS.mjs";
 import "node:module";
 import { Command } from "commander";
 import { AsyncLocalStorage } from "node:async_hooks";
 import * as fs from "fs/promises";
-import * as path from "path";
+import * as path$1 from "path";
 import * as readline from "readline";
 import { z } from "zod";
-import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { basename, dirname as dirname$1, join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { access, chmod, link, lstat, mkdir, open, rename, unlink as unlink$1 } from "node:fs/promises";
 
 //#region rolldown:runtime
 var __create = Object.create;
@@ -175,11 +178,11 @@ function sdkCommandApplicationResultSchema(value) {
 
 //#endregion
 //#region ../api/src/sdkOccurrenceResponseSchemas.ts
-const identifierSchema = z.string().min(1);
+const identifierSchema$1 = z.string().min(1);
 const timestampSchema = z.string().min(1);
 const sdkManagementEventOccurrenceSchema = z.object({
-	id: identifierSchema.transform(unsafeAsOccurrenceId),
-	seriesId: identifierSchema.transform(unsafeAsEventSeriesId),
+	id: identifierSchema$1.transform(unsafeAsOccurrenceId),
+	seriesId: identifierSchema$1.transform(unsafeAsEventSeriesId),
 	startsAt: timestampSchema,
 	endsAt: timestampSchema,
 	timeZone: z.string().min(1),
@@ -214,6 +217,125 @@ const sdkEventOccurrenceResponseSchema = z.object({ occurrence: sdkManagementEve
 const sdkDeleteEventOccurrenceResponseSchema = z.object({ deleted: z.literal(true) });
 const sdkReorderResponseSchema = z.object({ reordered: z.literal(true) });
 
+//#endregion
+//#region ../api/src/sdkMediaResponseSchemas.ts
+const identifierSchema = z.string().min(1);
+const nullablePathSchema = z.string().nullable();
+const managementMediaAssetSchema = z.object({
+	id: identifierSchema,
+	siteId: identifierSchema,
+	identifier: identifierSchema,
+	storageBucket: identifierSchema,
+	storagePath: identifierSchema,
+	filename: identifierSchema,
+	mimeType: identifierSchema,
+	width: z.number().int().nonnegative().nullable(),
+	height: z.number().int().nonnegative().nullable(),
+	bytes: z.number().int().nonnegative().nullable(),
+	checksumSha256: z.string().nullable(),
+	createdAt: identifierSchema,
+	updatedAt: identifierSchema
+});
+const blockLocationFields = {
+	siteId: identifierSchema,
+	blockId: identifierSchema,
+	blockKind: identifierSchema,
+	blockIdentifier: z.string().nullable(),
+	stage: z.enum(["draft", "published"])
+};
+const mediaUsageLocationSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("pageBlock"),
+		...blockLocationFields,
+		pageId: identifierSchema,
+		pageTitle: z.string().nullable(),
+		pageDraftPath: nullablePathSchema,
+		pagePublishedPath: nullablePathSchema
+	}),
+	z.object({
+		kind: z.literal("entrySlotBlock"),
+		...blockLocationFields,
+		entryId: identifierSchema,
+		entryTitle: z.string(),
+		typeKey: identifierSchema,
+		routeDraftPath: nullablePathSchema,
+		routePublishedPath: nullablePathSchema,
+		slotKey: identifierSchema
+	}),
+	z.object({
+		kind: z.literal("surfaceSlotBlock"),
+		...blockLocationFields,
+		pageSurfaceId: identifierSchema,
+		surfaceSlotId: identifierSchema,
+		slotKey: identifierSchema
+	}),
+	z.object({
+		kind: z.literal("contentEntry"),
+		siteId: identifierSchema,
+		entryId: identifierSchema,
+		entryTitle: z.string(),
+		typeKey: identifierSchema,
+		routeDraftPath: nullablePathSchema,
+		routePublishedPath: nullablePathSchema,
+		stage: z.enum(["draft", "published"])
+	}),
+	z.object({
+		kind: z.literal("productFileDownload"),
+		siteId: identifierSchema,
+		productId: identifierSchema,
+		productTitle: z.string()
+	})
+]);
+const mediaUsageItemSchema = z.object({
+	assetId: identifierSchema,
+	filename: z.string().nullable(),
+	usedCount: z.number().int().nonnegative(),
+	locations: z.array(mediaUsageLocationSchema)
+});
+const mediaDeleteWarningSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("ORPHAN_CLEANUP_FAILED"),
+	message: z.string(),
+	storageBucket: identifierSchema,
+	storagePath: identifierSchema
+}), z.object({
+	kind: z.literal("LABEL_CLEANUP_FAILED"),
+	message: z.string()
+})]);
+const sdkMediaListResponseSchema = z.object({
+	items: z.array(managementMediaAssetSchema),
+	total: z.number().int().nonnegative(),
+	limit: z.number().int().positive(),
+	offset: z.number().int().nonnegative(),
+	nextOffset: z.number().int().nonnegative().optional()
+});
+const sdkMediaDownloadResponseSchema = z.object({
+	transferUrl: z.string().url(),
+	asset: managementMediaAssetSchema
+});
+const sdkMediaDeletePreviewResponseSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("missing") }),
+	z.object({
+		kind: z.literal("in_use"),
+		usage: mediaUsageItemSchema
+	}),
+	z.object({
+		kind: z.literal("deletable"),
+		assetId: identifierSchema
+	})
+]);
+const sdkMediaDeleteApplyResponseSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("missing") }),
+	z.object({
+		kind: z.literal("in_use"),
+		usage: mediaUsageItemSchema
+	}),
+	z.object({ kind: z.literal("deleted") }),
+	z.object({
+		kind: z.literal("deleted_with_warnings"),
+		warnings: z.tuple([mediaDeleteWarningSchema], mediaDeleteWarningSchema)
+	})
+]);
+
 //#endregion
 //#region ../blocks/src/system/types/link.ts
 const nullableString = z.union([z.string().min(1), z.null()]);
@@ -285,16 +407,16 @@ function visitLinkValueReferences(value, visitor) {
 	if (!parsed.success) {
 		return;
 	}
-	const link = parsed.data;
-	switch (link.kind) {
+	const link$1 = parsed.data;
+	switch (link$1.kind) {
 		case "internal":
-			visitor.routeIds.add(link.routeId);
+			visitor.routeIds.add(link$1.routeId);
 			return;
 		case "page":
-			visitor.pageIdentifiers.add(link.identifier);
+			visitor.pageIdentifiers.add(link$1.identifier);
 			return;
 		case "entry":
-			visitor.entryIdentifiers.add(link.contentType, link.identifier);
+			visitor.entryIdentifiers.add(link$1.contentType, link$1.identifier);
 			return;
 		case "external":
 		case "url": return;
@@ -9249,6 +9371,11 @@ const gradientConfigSchema = z.object({
 	position: z.string().optional(),
 	stops: z.array(gradientStopSchema).min(2)
 });
+const gradientsSchema = z.object({
+	button: z.string().min(1).nullable().optional(),
+	hero: z.string().min(1).nullable().optional(),
+	background: z.string().min(1).nullable().optional()
+});
 
 //#endregion
 //#region ../theme-core/src/interactive/baseSchema.ts
@@ -10474,12 +10601,33 @@ const headerContainerSchema = z.object({
 
 //#endregion
 //#region ../theme-core/src/header/interactionPalette.ts
-const headerInteractionPaletteValues = [
+/**
+* The palettes that fill the nav link with a colour on hover and focus. Each
+* one names a background/foreground token pair.
+*/
+const headerInteractionPillPaletteValues = [
 	"primary",
 	"secondary",
 	"accent"
 ];
+/**
+* "No pill": the nav link keeps whatever hover treatment its recipe compiled,
+* and the palette step writes nothing at all (#1318 Phase 4c decision 2).
+*
+* It exists because "a colour change on hover, no filled background" was not
+* expressible in the vocabulary, and it is what
+* `anna-raven-therapy-and-yoga` and `kirtan-lucy` have rendered since before
+* the palette existed. Without it those two rows can only be classified as a
+* conscious visual change.
+*/
+const headerInteractionQuietPalette = "quiet";
+const headerInteractionPaletteValues = [...headerInteractionPillPaletteValues, headerInteractionQuietPalette];
 const headerInteractionPaletteSchema = z.enum(headerInteractionPaletteValues);
+/**
+* Narrowed to the pill palettes on purpose: `'quiet'` has no token pair, and a
+* caller that reaches this function without excluding it first is a type error
+* rather than a runtime surprise.
+*/
 function headerInteractionPalettePair(palette) {
 	switch (palette) {
 		case "primary": return {
@@ -10879,11 +11027,12 @@ const inputStyle = z.object({
 	]),
 	label: z.enum(["inside", "above"])
 });
-const headerPositioning = z.enum([
+const headerPositioningValues = [
 	"static",
 	"sticky",
 	"fixed"
-]);
+];
+const headerPositioning = z.enum(headerPositioningValues);
 const headerNavStyle = z.enum([
 	"minimal",
 	"underline",
@@ -11018,7 +11167,7 @@ const headerSchema = z.object({
 	variant: headerVariantWithLegacyAliasSchema,
 	positioning: headerPositioning,
 	shrinkOnScroll: z.boolean(),
-	maxWidth: headerMaxWidth,
+	maxWidth: headerMaxWidth.default("container"),
 	scrollTreatment: headerScrollTreatmentSchema,
 	background: headerBackgroundSchema.default({
 		type: "color",
@@ -11212,11 +11361,6 @@ const bodyTextSchema = z.object({ intro: z.object({
 	paragraphSize: bodyTextIntroTypographySizeSchema.optional(),
 	headingSize: bodyTextIntroTypographySizeSchema.optional()
 }).optional() }).optional();
-const gradientsSchema = z.object({
-	button: z.string().min(1).nullable().optional(),
-	hero: z.string().min(1).nullable().optional(),
-	background: z.string().min(1).nullable().optional()
-});
 /**
 * Testimonial quote-mark treatment, owned by the site style (analogous to the
 * accordion icon). `style` is the coarse selector; the optional fields fine-tune
@@ -11832,7 +11976,7 @@ function resolveAccessibleSurface(input) {
 			threshold,
 			rejectedCandidates
 		});
-		const link = resolveRequiredForeground({
+		const link$1 = resolveRequiredForeground({
 			role: "link",
 			candidates: recipe.linkCandidates,
 			backgroundToken,
@@ -11841,7 +11985,7 @@ function resolveAccessibleSurface(input) {
 			threshold,
 			rejectedCandidates
 		});
-		if (!heading || !text || !link) continue;
+		if (!heading || !text || !link$1) continue;
 		const supporting = resolveSupportingForeground({
 			candidates: recipe.supportingCandidates,
 			backgroundToken,
@@ -11861,7 +12005,7 @@ function resolveAccessibleSurface(input) {
 			},
 			heading,
 			text,
-			link,
+			link: link$1,
 			supporting,
 			rejectedCandidates
 		};
@@ -13303,6 +13447,32 @@ function replaceSiteStyleCompilationPlan(input) {
 		footerLookId: input.footerLookId ?? null
 	};
 }
+/**
+* Writes the brand display / logo size preference onto the header's logo style.
+*
+* Moved here from preview-next in #1318 Phase 4a so the header preference
+* pipeline can be composed once, in theme-core, rather than half in the client.
+*/
+function withHeaderBrandThemePreferences(theme, preferences) {
+	const currentLogo = theme.header.logo;
+	if (!currentLogo && preferences.brandDisplay === defaultHeaderBrandPreferences.brandDisplay && preferences.logoSize === defaultHeaderBrandPreferences.logoSize) {
+		return theme;
+	}
+	return {
+		...theme,
+		header: {
+			...theme.header,
+			logo: {
+				fontFamily: currentLogo?.fontFamily ?? "heading",
+				letterSpacing: currentLogo?.letterSpacing ?? "normal",
+				gradient: currentLogo?.gradient ?? false,
+				...currentLogo ?? {},
+				brandDisplay: preferences.brandDisplay,
+				size: preferences.logoSize
+			}
+		}
+	};
+}
 
 //#endregion
 //#region ../theme-core/src/site-styles/schemaVersionedJson.ts
@@ -16465,6 +16635,62 @@ const overlayLogoAccommodations = [
 	inlineMarkWithTitleLogoAccommodation,
 	unbackedOverlayLogoAccommodation
 ];
+const allCuratedLogoAccommodations = [
+	...inlineClassicLogoAccommodations,
+	...centeredLogoAccommodations,
+	...overlayLogoAccommodations
+];
+/**
+* Whether an accommodation pattern draws its own backing behind the logo.
+* Derived from the catalogue above rather than restated, so a new backing
+* accommodation cannot drift out of sync with this answer. Patterns declared in
+* `LogoAccommodationPattern` but not offered by any layout resolve to `false`,
+* which is the honest answer: nothing can select them.
+*/
+const backingLogoAccommodationPatterns = new Set(allCuratedLogoAccommodations.filter((option) => option.providesBacking === true).map((option) => option.pattern));
+function logoAccommodationProvidesBacking(pattern) {
+	return backingLogoAccommodationPatterns.has(pattern);
+}
+/**
+* The single answer to "what shape is this site's logo" (#1318 Phase 4b).
+*
+* The server and the public frontend each had their own copy of this, and they
+* disagreed on the one case that matters: a logo whose dimensions are unknown.
+* The server assumed `horizontal`; the frontend asked whether the persisted
+* accommodation brings its own backing and answered `square` if it does. The
+* richer rule is the correct one — a badge or masthead accommodation is
+* evidence about the asset that raw dimensions would otherwise supply — and it
+* reduces to `horizontal` whenever there is no backing, so it subsumes the
+* server's rule rather than contradicting it. The backing question goes through
+* `logoAccommodationProvidesBacking`, so the pattern list has one home.
+*/
+function deriveHeaderLogoShape({ asset, accommodation }) {
+	if (!asset) return "text-only";
+	if (!asset.width || !asset.height) {
+		return accommodation !== undefined && logoAccommodationProvidesBacking(accommodation) ? "square" : "horizontal";
+	}
+	return deriveHeaderLogoShapeFromDimensions(asset);
+}
+/**
+* The site's logo as the header pipeline sees it, from the two database values
+* that describe it: the asset (or its absence) and the accommodation the row
+* currently persists, which is evidence about the asset when its dimensions are
+* missing.
+*
+* One definition, shared by every shell that has to answer it — the dashboard's
+* `loadHeaderLogoContextForSite`, the public frontend, and the Phase 4c repair
+* generator — because a second copy is a second answer to "what shape is this
+* site's logo", and the two former copies disagreed on exactly the case this
+* one is careful about (#1318 Phase 4b/4c).
+*/
+function headerLogoShapeContext(input) {
+	return {
+		kind: "shape",
+		shape: deriveHeaderLogoShape(input),
+		...input.brand?.brandDisplay === undefined ? {} : { brandDisplayMode: input.brand.brandDisplay },
+		...input.brand?.logoSize === undefined ? {} : { sizePolicy: input.brand.logoSize }
+	};
+}
 function logoFactsForHeaderContext(logo) {
 	if (logo.kind === "facts") return logo.facts;
 	switch (logo.shape) {
@@ -16505,22 +16731,6 @@ function requireHeaderBrandPresentationSelection(plan) {
 	if (plan.kind === "selected") return plan;
 	throw new Error(`Selected header layout did not have a compatible logo accommodation: ${plan.reasons.join(", ")}`);
 }
-/**
-* Starts each compilation from the generated theme's header branch, then
-* clears optional nested styling fields that would otherwise leak from a
-* different header selection.
-*/
-function baseHeader(theme) {
-	const { navLinkStyle: _navLinkStyle, navFontRole: _navFontRole, navTextSize: _navTextSize, dropdownStyle: _dropdownStyle, ctaVariant: _ctaVariant, navContainer: _navContainer, container: _container, shadow: _shadow, logo: _logo, logoText: _logoText, border: _border, ...header } = theme.header;
-	return {
-		...header,
-		navContainer: {
-			type: "none",
-			tint: null,
-			opacity: .15
-		}
-	};
-}
 const headerLayoutCatalog = defineExactCatalog()([
 	{
 		id: asHeaderLayoutId("classic"),
@@ -16854,6 +17064,10 @@ const clearSplitInteractionPalette = defineLookOptionGroup({
 		{
 			id: "secondary",
 			label: "Secondary"
+		},
+		{
+			id: headerInteractionQuietPalette,
+			label: "Text only"
 		}
 	]
 });
@@ -16887,10 +17101,11 @@ function availableControlState(group, preference, effectivePalette, repair$1) {
 }
 function applyHeaderInteractionPalette(header, group, preference) {
 	if (!group) return header;
+	const palette = resolveHeaderInteractionPalette(group, preference).option.id;
+	if (palette === headerInteractionQuietPalette) return header;
 	if (!header.navLinkStyle) {
 		throw new Error(`Header interaction palette "${group.id}" requires a nav link style.`);
 	}
-	const palette = resolveHeaderInteractionPalette(group, preference).option.id;
 	const pair = headerInteractionPalettePair(palette);
 	const pillEffect = {
 		effectId: "background-on-hover",
@@ -16919,6 +17134,103 @@ function resolveHeaderInteractionPalette(group, preference) {
 function defaultOptionLabel(group) {
 	return resolveLookOption(group, undefined).option.label;
 }
+/**
+* The four fields `applyHeaderInteractionPalette` writes, normalised so the
+* comparison below can be made against bytes that came back out of `jsonb`.
+*
+* `hoverColorToken` collapses absent to `null` because the palette writes an
+* explicit `null` where a pre-palette row simply has no key, and the two mean
+* the same thing.
+*/
+function headerInteractionPaletteFields(header) {
+	return {
+		hoverColorToken: header.navLinkStyle?.hoverColorToken ?? null,
+		borderRadius: header.navLinkStyle?.borderRadius,
+		hover: header.navLinkStyle?.effects?.hover,
+		focus: header.navLinkStyle?.effects?.focus
+	};
+}
+/**
+* Key-sorted serialisation, because one side of the comparison is built here
+* and the other comes back out of `jsonb` in whatever order it was stored.
+* `JSON.stringify` alone reported two identical effect lists as different,
+* which is the same key-order trap the `logoText` derivation hit in Phase 4a.
+*/
+function canonicalJson(value) {
+	if (Array.isArray(value)) {
+		return `[${value.map(canonicalJson).join(",")}]`;
+	}
+	if (typeof value === "object" && value !== null) {
+		const entries = Object.entries(value).filter(([, member]) => member !== undefined).sort(([left], [right]) => left.localeCompare(right));
+		return `{${entries.map(([key, member]) => `${JSON.stringify(key)}:${canonicalJson(member)}`).join(",")}}`;
+	}
+	return value === undefined ? "undefined" : JSON.stringify(value);
+}
+/**
+* The effect id the palette writes. A nav link carrying it is "palette-shaped":
+* its hover treatment is a filled pill rather than the plain colour change a
+* pre-palette recipe compiles.
+*/
+const paletteEffectId = "background-on-hover";
+function carriesPaletteShapedEffect(header) {
+	const effects = header.navLinkStyle?.effects;
+	return [effects?.hover, effects?.focus].some((list) => (list ?? []).some((effect) => effect.effectId === paletteEffectId));
+}
+/**
+* Which option of `group` a persisted header's nav link style is the output of
+* (#1318 Phase 4c decision 2).
+*
+* This is a baseline comparison rather than a pattern match on effect bytes.
+* The palette overwrites its four fields unconditionally, so applying an option
+* to a header leaves that header unchanged exactly when the header is already
+* that option's output — which makes "which option produced these bytes" a
+* fixed-point search over the closed option list.
+*
+* Order is load-bearing twice over:
+*
+* - `'recommended'` is tried first, so a row compiled from the recommendation
+*   derives the sentinel rather than the default option's own id. As with the
+*   structure rule, an explicit choice that happens to equal the default
+*   collapses to the sentinel; nothing in the bytes distinguishes the two.
+* - `'quiet'` is tried last, because it writes nothing and is therefore a fixed
+*   point of every header. Reaching it means no pill option produced these
+*   bytes — which is what "this row renders no pill" means, *provided the row
+*   carries no pill*. `carriesPaletteShapedEffect` is that proviso: a
+*   palette-shaped nav link that no option reproduces is `'unrecognised'`, not
+*   `'quiet'`.
+*/
+function classifyHeaderInteractionPaletteBytes(header, group) {
+	if (!group) return { kind: "no-palette" };
+	if (!header.navLinkStyle) return { kind: "no-palette" };
+	const persisted = canonicalJson(headerInteractionPaletteFields(header));
+	const match = orderedPaletteCandidates(group).find((candidate$1) => canonicalJson(headerInteractionPaletteFields(applyHeaderInteractionPalette(header, group, candidate$1))) === persisted);
+	if (match === undefined) return { kind: "unrecognised" };
+	if (match === headerInteractionQuietPalette && carriesPaletteShapedEffect(header)) {
+		return { kind: "unrecognised" };
+	}
+	return {
+		kind: "derived",
+		preference: match
+	};
+}
+/**
+* The preference `classifyHeaderInteractionPaletteBytes` derived, or `null`
+* when the bytes express none — either because the style offers no palette or
+* because they match no option it does offer. Callers that need to tell those
+* two apart use the classification directly.
+*/
+function readHeaderInteractionPaletteFromBytes(header, group) {
+	const classified = classifyHeaderInteractionPaletteBytes(header, group);
+	return classified.kind === "derived" ? classified.preference : null;
+}
+function orderedPaletteCandidates(group) {
+	const ids = group.options.map((option) => option.id);
+	return [
+		"recommended",
+		...ids.filter((id) => id !== headerInteractionQuietPalette),
+		...ids.filter((id) => id === headerInteractionQuietPalette)
+	];
+}
 
 //#endregion
 //#region ../theme-core/src/site-styles/headerStyleDefaults.ts
@@ -17589,10 +17901,37 @@ function recipeCta(cta, theme) {
 		...cta.gap ? { ctaGap: cta.gap } : {}
 	};
 }
-/** Layout-derived structure. The only part of the header a recipe cannot reach. */
-function headerForLayout(theme, layout) {
+/**
+* Layout-derived structure. The only part of the header a recipe cannot reach.
+*
+* It used to start from `baseHeader(theme)` — the previous header with the
+* style-owned keys stripped — which is what let a value hand-edited once
+* survive every later recompile. Phase 4e deleted that (#1318): the layout
+* writes its own fields and nothing else arrives from the theme's header.
+*
+* Three fields moved here as a result, each with a named producer rather than
+* an inherited value:
+*
+* - `maxWidth` is the constant `'container'` (D16). It is layout-owned with one
+*   value; `headerSchema` makes it required on the *output* type, so a
+*   `.default()` at the parse boundary would not do — that would be a hidden
+*   authority, which is the thing this slice removes.
+* - `navContainer` is `baseHeader`'s old default, which a `frame: {kind:'none'}`
+*   recipe still relies on being present rather than omitted.
+* - `scrollTreatment` and `interactionPalette` are deliberately **absent**.
+*   Neither is compiled here: `scrollTreatment` is written at render time by
+*   `applyOpeningForeground` from the page's own context, and the interaction
+*   palette's marker field is written by `applyHeaderPreferences` from the
+*   record. Both used to reach the output only by surviving `baseHeader`.
+*/
+function headerForLayout(layout) {
 	return {
-		...baseHeader(theme),
+		maxWidth: "container",
+		navContainer: {
+			type: "none",
+			tint: null,
+			opacity: .15
+		},
 		variant: layout.variant,
 		positioning: layout.defaultPositioning,
 		shrinkOnScroll: layout.shrinkOnScroll,
@@ -17607,12 +17946,19 @@ function headerForLayout(theme, layout) {
 /**
 * The single header interpreter. Pure and total: same `(theme, layout, recipe)`
 * in, same object out, no throws of its own.
+*
+* It **constructs** a `ThemeHeader` rather than starting from one (#1318 Phase
+* 4e). `theme` is read for the palette-dependent facets only — the themed
+* shadow and the CTA variant — never for `theme.header`, so no value can
+* survive a recompile by accident. Every required field of `headerSchema` is
+* produced by a named branch here or in `headerForLayout`; the type is the
+* check.
 */
 function compileHeaderRecipe(theme, layout, recipe) {
 	const effective = effectiveRecipe(layout, recipe);
 	const navLinkStyle = recipeNavLinkStyle(effective);
 	return {
-		...headerForLayout(theme, layout),
+		...headerForLayout(layout),
 		textColor: toneColorToken(effective.tone),
 		navColor: toneColorToken(effective.tone),
 		dropdownStyle: toneDropdownStyle(effective.tone),
@@ -17646,11 +17992,19 @@ function compileHeaderRecipe(theme, layout, recipe) {
 * site style has to say so, because silently falling back to the catalogue
 * default is exactly the ownership leak this slice closes. Pass `null` when
 * there genuinely is no site style (initial site provisioning).
-*/
-function compileHeaderLayoutStyleSelection(theme, resolution, siteStyle) {
+*
+* `interactionPalette` is a parameter rather than a read off
+* `theme.header.interactionPalette` (#1318 Phase 4c). The marker field on the
+* header is where the preference is *persisted*, but taking it from there made
+* the palette the one preference the compiler could not be told about — which
+* is invisible while the marker always equals what was compiled and wrong the
+* moment a backfill supplies a different one. The caller that owns the
+* preference record now says which palette to compile.
+*/
+function compileHeaderLayoutStyleSelection(theme, resolution, siteStyle, interactionPalette) {
 	const recipe = resolveHeaderStyleRecipe(siteStyle, resolution.style.id);
 	const header = compileHeaderRecipe(theme, resolution.layout, recipe);
-	return applyHeaderInteractionPalette(header, recipe.interactionPalette, theme.header.interactionPalette ?? "recommended");
+	return applyHeaderInteractionPalette(header, recipe.interactionPalette, interactionPalette);
 }
 
 //#endregion
@@ -20166,10 +20520,22 @@ function defaultPaletteForSiteStyle(siteStyle) {
 	return defaultCuratedChoice(siteStyle.paletteRecommendations);
 }
 function defaultHeaderSelectionForSiteStyle(siteStyle) {
+	return defaultHeaderCurationForSiteStyle(siteStyle).selection;
+}
+/**
+* The curated default selection together with the style choices that belong to
+* it. Carrying the styles alongside the ids is what lets a caller fall back to
+* the default layout without a second, nullable lookup that can never actually
+* miss — the source of an unreachable throw before #1318 Phase 4a.
+*/
+function defaultHeaderCurationForSiteStyle(siteStyle) {
 	const [{ layout, styles }] = siteStyle.headerCuration;
 	return {
-		layoutId: layout.id,
-		styleId: styles[0].id
+		selection: {
+			layoutId: layout.id,
+			styleId: styles[0].id
+		},
+		styles
 	};
 }
 function headerLayoutChoicesForSiteStyle(siteStyle) {
@@ -22724,6 +23090,878 @@ function reinterpretForSiteStyle(input) {
 	};
 }
 
+//#endregion
+//#region ../theme-core/src/site-styles/siteChromeBackgrounds.ts
+const siteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceColorTokenNames);
+const quickSiteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceQuickColorTokenNames);
+const advancedSiteChromeBackgroundColorTokens = siteChromeBackgroundColorTokens.filter((token) => !quickSiteChromeBackgroundColorTokens.includes(token));
+const defaultSiteChromeBackgroundOverride = { kind: "default" };
+function defaultSiteChromeBackgroundPreferences() {
+	return {
+		header: defaultSiteChromeBackgroundOverride,
+		footer: defaultSiteChromeBackgroundOverride
+	};
+}
+function parseSiteChromeBackgroundColorToken(value) {
+	const token = parseBackgroundAppearanceColorToken(value);
+	return token ? token : null;
+}
+function siteChromeBackgroundPreferencesFromTheme(theme) {
+	if (!theme) return defaultSiteChromeBackgroundPreferences();
+	return {
+		header: theme.header ? siteChromeBackgroundOverrideFromHeader(theme.header) : defaultSiteChromeBackgroundOverride,
+		footer: theme.footer ? siteChromeBackgroundOverrideFromFooter(theme.footer) : defaultSiteChromeBackgroundOverride
+	};
+}
+function applySiteChromeBackgroundPreferences(theme, preferences) {
+	return {
+		...theme,
+		header: applyHeaderBackgroundOverride(theme, theme.header, preferences.header),
+		footer: applyFooterBackgroundOverride(theme, theme.footer, preferences.footer)
+	};
+}
+function canCustomizeSiteChromeBackground(theme, surface$1) {
+	if (surface$1 === "footer") return true;
+	const header = theme?.header;
+	if (!header) return false;
+	const navContainerType = header.navContainer?.type ?? "none";
+	return header.variant !== "floating" && navContainerType !== "glass" && navContainerType !== "pill";
+}
+function siteChromeBackgroundOverrideLabel(override) {
+	switch (override.kind) {
+		case "default": return "Default";
+		case "color": return formatSiteChromeBackgroundTokenLabel(override.token);
+	}
+}
+function formatSiteChromeBackgroundTokenLabel(token) {
+	return String(token).replace(/-/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+function siteChromeBackgroundOverrideEquals(left, right) {
+	return left.kind === right.kind && (left.kind === "default" || right.kind === "color" && left.token === right.token);
+}
+function cycleSiteChromeBackgroundOverride(current, direction) {
+	const fallback = direction === "next" ? quickSiteChromeBackgroundColorTokens[0] : quickSiteChromeBackgroundColorTokens[quickSiteChromeBackgroundColorTokens.length - 1];
+	if (!fallback) return defaultSiteChromeBackgroundOverride;
+	if (current.kind === "default") {
+		return {
+			kind: "color",
+			token: fallback
+		};
+	}
+	const currentIndex = quickSiteChromeBackgroundColorTokens.indexOf(current.token);
+	if (currentIndex === -1) {
+		return {
+			kind: "color",
+			token: fallback
+		};
+	}
+	const nextIndex = direction === "next" ? (currentIndex + 1) % quickSiteChromeBackgroundColorTokens.length : currentIndex === 0 ? quickSiteChromeBackgroundColorTokens.length - 1 : currentIndex - 1;
+	const token = requiredQuickSiteChromeBackgroundColorToken(nextIndex);
+	return {
+		kind: "color",
+		token
+	};
+}
+/**
+* Reads the header background override back out of persisted bytes. Exported
+* for `readHeaderPreferences`, which needs the header half on its own.
+*/
+function siteChromeBackgroundOverrideFromHeader(header) {
+	return siteChromeBackgroundOverrideFromBackground(header.background);
+}
+function siteChromeBackgroundOverrideFromFooter(footer) {
+	return siteChromeBackgroundOverrideFromBackground(footer.background);
+}
+function siteChromeBackgroundOverrideFromBackground(background) {
+	if (background?.contentOwner !== siteChromeBackgroundOverrideOwner || background.type !== "color") {
+		return defaultSiteChromeBackgroundOverride;
+	}
+	const token = parseSiteChromeBackgroundColorToken(background.color);
+	return token ? {
+		kind: "color",
+		token
+	} : defaultSiteChromeBackgroundOverride;
+}
+/**
+* Header-only background applier. Exported so the header preference pipeline
+* can apply the header override without going through
+* `applySiteChromeBackgroundPreferences`, which also writes the footer and
+* would clobber footer intent (#1318 Correction 20).
+*/
+function applyHeaderBackgroundOverride(theme, header, override) {
+	if (override.kind === "default") return header;
+	const background = siteChromeColorBackground(override.token);
+	const foreground = resolveChromeForegroundToken(theme, background);
+	return {
+		...header,
+		background: {
+			...background,
+			textColor: foreground
+		},
+		textColor: foreground,
+		navColor: foreground,
+		...header.navLinkStyle ? { navLinkStyle: {
+			...header.navLinkStyle,
+			colorToken: foreground
+		} } : {}
+	};
+}
+/**
+* Footer-only background applier, the counterpart of
+* `applyHeaderBackgroundOverride`. Exported so a caller that owns one surface
+* can write that surface rather than passing a no-op override for the other
+* (#1318 Correction 20).
+*/
+function applyFooterBackgroundOverride(theme, footer, override) {
+	if (override.kind === "default") return footer;
+	const background = siteChromeColorBackground(override.token);
+	const foreground = resolveChromeForegroundToken(theme, background);
+	return {
+		...footer,
+		background: {
+			...background,
+			textColor: foreground
+		},
+		navColor: foreground,
+		...footer.navLinkStyle ? { navLinkStyle: {
+			...footer.navLinkStyle,
+			colorToken: foreground
+		} } : {},
+		...footer.bottomTextLinkStyle ? { bottomTextLinkStyle: {
+			...footer.bottomTextLinkStyle,
+			colorToken: foreground
+		} } : {},
+		...footer.bottomBar ? { bottomBar: {
+			...footer.bottomBar,
+			textColor: foreground
+		} } : {}
+	};
+}
+function resolveChromeForegroundToken(theme, background) {
+	const resolved = resolveSurfaceForeground(background, expandPalette(theme.palette));
+	if (resolved.kind === "unknown") {
+		throw new Error(`Site chrome background "${background?.type === "color" ? background.color ?? "unknown" : "unknown"}" has no resolvable AA foreground; the theme palette is incomplete`);
+	}
+	return resolved.roles.text;
+}
+function siteChromeColorBackground(color) {
+	return {
+		type: "color",
+		contentOwner: siteChromeBackgroundOverrideOwner,
+		color
+	};
+}
+function toSiteChromeBackgroundColorTokens(tokenNames) {
+	return tokenNames.flatMap((name) => {
+		const token = parseSiteChromeBackgroundColorToken(name);
+		return token ? [token] : [];
+	});
+}
+function requiredQuickSiteChromeBackgroundColorToken(index) {
+	const token = quickSiteChromeBackgroundColorTokens[index];
+	if (!token) {
+		throw new Error(`Missing quick site chrome background token at index ${index}`);
+	}
+	return token;
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/siteChromeNavPreferences.ts
+const headerNavTypographyPreferenceValues = [
+	"inherit",
+	"body",
+	"heading"
+];
+const headerNavFontSizePreferenceValues = [
+	"inherit",
+	"sm",
+	"base",
+	"lg",
+	"xl"
+];
+const headerNavTypographyOptions = [
+	{
+		value: "inherit",
+		label: "Default"
+	},
+	{
+		value: "body",
+		label: "Body"
+	},
+	{
+		value: "heading",
+		label: "Heading"
+	}
+];
+const headerNavFontSizeOptions = [
+	{
+		value: "inherit",
+		label: "Default"
+	},
+	{
+		value: "sm",
+		label: "Small"
+	},
+	{
+		value: "base",
+		label: "Regular"
+	},
+	{
+		value: "lg",
+		label: "Large"
+	},
+	{
+		value: "xl",
+		label: "Huge"
+	}
+];
+const defaultHeaderNavPreferences = {
+	typography: "inherit",
+	fontSize: "inherit",
+	interactionPalette: "recommended"
+};
+function readHeaderNavPreferences(theme) {
+	const typography = theme?.header?.navFontRole;
+	const fontSize = theme?.header?.navTextSize;
+	const interactionPalette = readHeaderInteractionPalettePreference(theme?.header?.interactionPalette);
+	return typography === "body" || typography === "heading" ? {
+		typography,
+		fontSize: readHeaderNavFontSizePreference(fontSize),
+		interactionPalette
+	} : {
+		...defaultHeaderNavPreferences,
+		fontSize: readHeaderNavFontSizePreference(fontSize),
+		interactionPalette
+	};
+}
+/**
+* Closes over the palette vocabulary rather than trusting the stored value: a
+* persisted header is `jsonb` and can carry anything, and a bare `?? ` would
+* pass a malformed value straight through as if it were a preference.
+*/
+function readHeaderInteractionPalettePreference(value) {
+	return headerInteractionPaletteValues.find((palette) => palette === value) ?? "recommended";
+}
+function headerNavPreferencesEqual(left, right) {
+	return left.typography === right.typography && left.fontSize === right.fontSize && left.interactionPalette === right.interactionPalette;
+}
+function withHeaderNavThemePreferences(theme, preferences) {
+	const { navFontRole: _navFontRole, navTextSize: _navTextSize, interactionPalette: _interactionPalette, ...headerWithoutPreference } = theme.header;
+	const nextHeader = {
+		...headerWithoutPreference,
+		...preferences.typography === "inherit" ? {} : { navFontRole: preferences.typography },
+		...preferences.fontSize === "inherit" ? {} : { navTextSize: preferences.fontSize },
+		...preferences.interactionPalette === "recommended" ? {} : { interactionPalette: preferences.interactionPalette }
+	};
+	return {
+		...theme,
+		header: nextHeader
+	};
+}
+/**
+* Applies the user's nav font-role/size overrides on top of a style-resolved
+* nav link style. This is where the precedence contract lands:
+*
+* - The nav typography TREATMENT (case/tracking identity: plain / heading /
+*   quiet-caps / brand-caps) is ALWAYS owned by the active header style and is
+*   baked into `style` before this call (see `applyNavTypography` in
+*   headerLayoutStyles.ts).
+* - Each treatment resolves through a DEFAULT font role: `heading` resolves
+*   through the heading role; `plain` / `quiet-caps` / `brand-caps` resolve
+*   through the body role.
+* - The user's `navFontRole` (surfaced here as `preferences.typography`) only
+*   overrides which font ROLE the treatment resolves through. It never changes
+*   the treatment. `'inherit'` keeps the treatment's default role.
+*/
+function mergeHeaderNavTypographyPreference(style, preferences) {
+	return preferences.typography === "inherit" && preferences.fontSize === "inherit" ? style : {
+		...style,
+		...preferences.typography === "inherit" ? {} : { typography: preferences.typography },
+		...preferences.fontSize === "inherit" ? {} : { textSize: preferences.fontSize }
+	};
+}
+function readHeaderNavFontSizePreference(value) {
+	return value === "sm" || value === "base" || value === "lg" || value === "xl" ? value : "inherit";
+}
+/**
+* The nav size a header actually renders at, from either of the two places it
+* can be written.
+*
+* `generateHeaderCss` merges `header.navTextSize` over `navLinkStyle.textSize`
+* at render time (`mergeHeaderNavTypographyPreference`), so the marker field
+* wins when it is present and the compiled nav link style supplies the size
+* otherwise. Reading only the marker — which is what
+* `readHeaderNavPreferences` does, and correctly, because it answers "what does
+* the control show" — misses a size that reached the row through the compiled
+* bytes instead.
+*/
+function headerNavEffectiveFontSize(header) {
+	const marker = readHeaderNavFontSizePreference(header.navTextSize);
+	return marker === "inherit" ? readHeaderNavFontSizePreference(header.navLinkStyle?.textSize) : marker;
+}
+/**
+* `navTextSize` derived as a preference by baseline comparison (#1318 Phase 4c
+* decision 1) — the same rule the structure fields already use: compare the
+* persisted value against what the row's own (layout, recipe) compiles, emit
+* `'inherit'` when they agree and the explicit value when they do not.
+*
+* The reason it needs the rule at all is that nav size is one of the fields a
+* pre-preferences row could only express by carrying it in the compiled bytes:
+* `heart-led-yoga` and `therese-millar-yoga` persist `navLinkStyle.textSize:
+* 'lg'` under a `serif-line` recipe that compiles no size, which is a user's
+* choice sitting in the wrong place. Reading only `header.navTextSize` derives
+* `'inherit'` there and a recompile would shrink their nav.
+*
+* Backfilling the derived value is pixel-preserving because the CSS merge above
+* makes `{navTextSize: 'lg'}` over a size-less nav link style render exactly
+* what `{navLinkStyle: {textSize: 'lg'}}` renders.
+*
+* **Two cases lose information, and both are accepted rather than accidental.**
+* The preference vocabulary is `inherit | sm | base | lg | xl` — there is no
+* value meaning "no size at all" — so `'inherit'` has to carry both of them:
+*
+* 1. *Persisted size equals the baseline.* Nothing in the bytes distinguishes
+*    "chose the size the recipe already compiles" from "never chose", so the
+*    marker field is dropped on recompile. **Pixel-neutral**: the recipe puts
+*    the same size back.
+* 2. *Persisted has no size and the baseline compiles one.* The row renders at
+*    the browser default and the recipe wants, say, `'sm'`; `'inherit'` is the
+*    only representable answer, so **the recompile adopts the baseline size and
+*    the row's sizeless-ness is lost**. This one is *not* pixel-neutral, and
+*    representing it properly would mean adding a `'none'` arm to the
+*    preference the way `HeaderStructurePreferences.logoText` has one.
+*
+* Case 2 is not silent. Adopting the baseline size is a byte change, so such a
+* row shows up as divergent in the Phase 4c report (`navLinkStyle.textSize
+* undefined -> "sm"`) and cannot reach Phase 4e unclassified — the report's
+* zero-rows gate is the safety net for exactly this. No row in either corpus is
+* in that state today; if one appears, it is a classification decision (widen
+* the vocabulary, or accept the size) rather than something this function may
+* guess at.
+*/
+function readHeaderNavFontSizeAgainstBaseline(persisted, compiled) {
+	const size = headerNavEffectiveFontSize(persisted);
+	return size === headerNavEffectiveFontSize(compiled) ? "inherit" : size;
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/headerBrandPresentation.ts
+/**
+* Whether the header wears a brand presentation at all (#1318 Phase 4c).
+*
+* `applyHeaderBrandPresentation` is unconditional today: given a logo context
+* it always writes a `logo` object carrying a resolved display, size and
+* accommodation. That makes "this header has no brand presentation block" —
+* which is what several live sites persist, including one whose site *does*
+* have a logo asset — a state the preference record could not express, so a
+* recompile would silently give the site a logo treatment it has never
+* rendered.
+*
+* This is the third field in this phase with that shape, after the interaction
+* palette and the nav text size: the persisted bytes carry intent the reader
+* cannot say, so the recompile "corrects" it. The fix is the same one — widen
+* the closed vocabulary with a named member and derive it by baseline
+* comparison — and it is a *widening*, not a restyle: `'recommended'` is the
+* default and reproduces today's behaviour exactly, so no row whose bytes carry
+* a presentation compiles differently for `'plain'` existing.
+*
+* `'plain'` is deliberately not "preserve whatever bytes are there". It is a
+* constructive instruction — *write no presentation block* — so Phase 4e's
+* compiler, which builds the header from nothing, can produce it.
+*/
+const headerBrandPresentationValues = ["recommended", "plain"];
+const defaultHeaderBrandPresentation = "recommended";
+/**
+* Key-order-safe structural equality over the persisted `logo` object.
+*
+* The persisted value comes back from `jsonb`, whose key order is not the order
+* the applier builds; a `JSON.stringify` comparison would read two equal logo
+* blocks as different and quietly classify a `'recommended'` row as
+* unrecognised — the same trap the interaction-palette transcription test
+* exists to catch.
+*/
+function jsonEquals(left, right) {
+	if (left === right) return true;
+	if (left === null || right === null) return false;
+	if (typeof left !== "object" || typeof right !== "object") return false;
+	if (Array.isArray(left) !== Array.isArray(right)) return false;
+	if (Array.isArray(left) && Array.isArray(right)) {
+		return left.length === right.length && left.every((value, index) => jsonEquals(value, right[index]));
+	}
+	const leftRecord = left;
+	const rightRecord = right;
+	const keys = new Set([...Object.keys(leftRecord), ...Object.keys(rightRecord)]);
+	for (const key of keys) {
+		if (!jsonEquals(leftRecord[key], rightRecord[key])) return false;
+	}
+	return true;
+}
+/**
+* The two keys the brand appliers write with a documented `'auto'` default, so
+* a persisted block that omits them means the same thing as one that spells
+* them out. This is the "implicit brand defaults made explicit" class the 4a
+* sweep pinned; treating it as a difference here would classify two live rows
+* as unrecognised over a value nobody chose and nothing renders differently.
+*/
+function withImplicitBrandDefaults(logo) {
+	return {
+		...logo,
+		brandDisplay: logo.brandDisplay ?? "auto",
+		size: logo.size ?? "auto"
+	};
+}
+/**
+* Equal modulo the implicit brand defaults, and `null`-tolerant on both sides:
+* an absent block and an absent block are the same answer.
+*/
+function logoBytesEqual(left, right) {
+	const leftAbsent = left === undefined || left === null;
+	const rightAbsent = right === undefined || right === null;
+	if (leftAbsent || rightAbsent) return leftAbsent && rightAbsent;
+	return jsonEquals(withImplicitBrandDefaults(left), withImplicitBrandDefaults(right));
+}
+/**
+* Which mode reproduces this row's persisted logo bytes.
+*
+* Both candidates are supplied rather than reconstructed here, because both are
+* the compilation's own output and rebuilding either would be a second
+* authority on what the modes mean. `'recommended'` is tested first so that a
+* row the resolver already agrees with keeps the live mode; `'plain'` is the
+* answer for the rows that carry no presentation — an absent block, or a block
+* holding only the recipe's own brand typography.
+*/
+function classifyHeaderBrandPresentationBytes(persisted, recommended, plain) {
+	if (logoBytesEqual(persisted.logo, recommended.logo)) {
+		return { kind: "recommended" };
+	}
+	if (logoBytesEqual(persisted.logo, plain.logo)) return { kind: "plain" };
+	return { kind: "unrecognised" };
+}
+/**
+* The preference the bytes express, or `null` when they express none the record
+* can carry. `null` is the caller's cue to fall back to the default and say so.
+*/
+function readHeaderBrandPresentationFromBytes(persisted, recommended, plain) {
+	const classification = classifyHeaderBrandPresentationBytes(persisted, recommended, plain);
+	return classification.kind === "unrecognised" ? null : classification.kind;
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/headerPreferences.ts
+const defaultHeaderStructurePreferences = {
+	positioning: "inherit",
+	shrinkOnScroll: "inherit",
+	logoText: "inherit"
+};
+const defaultHeaderPreferences = {
+	brandPresentation: defaultHeaderBrandPresentation,
+	brandDisplay: defaultHeaderBrandPreferences.brandDisplay,
+	logoSize: defaultHeaderBrandPreferences.logoSize,
+	navFontRole: defaultHeaderNavPreferences.typography,
+	navTextSize: defaultHeaderNavPreferences.fontSize,
+	interactionPalette: defaultHeaderNavPreferences.interactionPalette,
+	background: { kind: "default" },
+	structure: defaultHeaderStructurePreferences
+};
+/**
+* Field-wise rather than `JSON.stringify`: the persisted value comes back from
+* `jsonb` and the compiled one is built by the interpreter, so their key order
+* is not guaranteed to match and a string comparison would report two equal
+* records as different.
+*
+* The destructure is exhaustive on purpose — adding a field to
+* `headerLogoTextSchema` without deciding whether it participates in this
+* comparison breaks the build here rather than silently collapsing two
+* different records to `'inherit'`.
+*
+* Note the asymmetry this leaves at the edge: a persisted `{}` against a
+* compiled `undefined` is *not* equal, so it derives to an explicit `{}`
+* rather than to `'none'`. That is deliberate — the row does carry a logo-text
+* record, it just carries an empty one — but it means `'none'` means "no
+* record at all", never "a record with nothing in it".
+*/
+function headerLogoTextEquals(left, right) {
+	if (left === undefined || right === undefined) return left === right;
+	const comparisons = {
+		mobileWrapLines: left.mobileWrapLines === right.mobileWrapLines,
+		mobileMaxWidth: left.mobileMaxWidth === right.mobileMaxWidth,
+		hideOnShrink: left.hideOnShrink === right.hideOnShrink
+	};
+	return Object.values(comparisons).every((equal) => equal);
+}
+/**
+* Brand presentation runs *after* the structure preferences and forces
+* `shrinkOnScroll: true` for a display-size logo on a backing accommodation
+* over a non-static header (`applyHeaderBrandPresentation` below). On such a
+* row the persisted `true` therefore carries no intent — it would be written
+* whatever the user had chosen — so the field is not derivable there and
+* collapses to `'inherit'`.
+*
+* This reads the row's own persisted logo rather than a live logo context, so
+* it holds for callers that have no context to supply (the divergence report,
+* and 4c's backfill). A caller that *does* supply the presentation gets the
+* same answer through the baseline, which already carries the forced value.
+*/
+function headerBrandPresentationForcesShrink(header) {
+	const accommodation = header.logo?.accommodation;
+	return header.logo?.size === "display" && accommodation !== undefined && logoAccommodationProvidesBacking(accommodation) && header.positioning !== "static";
+}
+/**
+* The three structure fields are read back out of `jsonb`, so each one is
+* validated against its own vocabulary rather than trusted. A malformed value
+* expresses no intent, so it derives to `'inherit'` — never to a default that
+* would then be persisted as if the user had chosen it.
+*/
+function readPersistedPositioning(value) {
+	return headerPositioningValues.find((candidate$1) => candidate$1 === value) ?? null;
+}
+function readPersistedShrinkOnScroll(value) {
+	return typeof value === "boolean" ? value : null;
+}
+/** "Present, but not a value this field's vocabulary accepts." */
+const invalidField = Symbol("invalid persisted field");
+const logoTextWrapLines = [1, 2];
+const logoTextMobileMaxWidths = [
+	"xs",
+	"sm",
+	"md"
+];
+function readOptionalMember(value, allowed) {
+	if (value === undefined) return undefined;
+	return allowed.find((candidate$1) => candidate$1 === value) ?? invalidField;
+}
+function readOptionalBoolean(value) {
+	if (value === undefined) return undefined;
+	return typeof value === "boolean" ? value : invalidField;
+}
+function readPersistedLogoText(value) {
+	if (value === undefined) return { kind: "absent" };
+	if (typeof value !== "object" || value === null) return { kind: "invalid" };
+	const wrapLines = readOptionalMember(value.mobileWrapLines, logoTextWrapLines);
+	const maxWidth = readOptionalMember(value.mobileMaxWidth, logoTextMobileMaxWidths);
+	const hide = readOptionalBoolean(value.hideOnShrink);
+	if (wrapLines === invalidField || maxWidth === invalidField || hide === invalidField) {
+		return { kind: "invalid" };
+	}
+	return {
+		kind: "present",
+		value: {
+			...wrapLines === undefined ? {} : { mobileWrapLines: wrapLines },
+			...maxWidth === undefined ? {} : { mobileMaxWidth: maxWidth },
+			...hide === undefined ? {} : { hideOnShrink: hide }
+		}
+	};
+}
+function deriveLogoTextPreference(persisted, compiled) {
+	const read = readPersistedLogoText(persisted);
+	switch (read.kind) {
+		case "invalid": return "inherit";
+		case "absent": return compiled === undefined ? "inherit" : "none";
+		case "present": return headerLogoTextEquals(read.value, compiled) ? "inherit" : read.value;
+	}
+}
+/**
+* The written-down backfill rule (#1318 Phase 4a): compare the persisted value
+* against the value the row's own (layout, recipe) compiles, and emit
+* `'inherit'` when they are equal, the explicit value when they are not.
+*
+* Equal-to-default therefore collapses to `'inherit'`. Nothing in the data
+* distinguishes a deliberate "sticky, same as the default" from an untouched
+* row, so the backfill does not pretend to recover it; going forward the editor
+* records what the user picks and the distinction is real for new intent.
+*
+* Two qualifications on "the value it compiles", both of which keep the rule
+* from inventing intent:
+*
+* 1. A value that no vocabulary accepts expresses nothing, so it derives to
+*    `'inherit'` rather than to whatever a fallback would have picked.
+* 2. A field a later pipeline step overwrites unconditionally cannot carry
+*    intent at all. That is `shrinkOnScroll` on a display-logo row — see
+*    `headerBrandPresentationForcesShrink`.
+*/
+function readHeaderStructurePreferences(persisted, compiled) {
+	const positioning = readPersistedPositioning(persisted.positioning);
+	const shrinkOnScroll = readPersistedShrinkOnScroll(persisted.shrinkOnScroll);
+	return {
+		positioning: positioning === null || positioning === compiled.positioning ? "inherit" : positioning,
+		shrinkOnScroll: shrinkOnScroll === null || shrinkOnScroll === compiled.shrinkOnScroll || headerBrandPresentationForcesShrink(persisted) ? "inherit" : shrinkOnScroll,
+		logoText: deriveLogoTextPreference(persisted.logoText, compiled.logoText)
+	};
+}
+/**
+* Total over any persisted theme, including a malformed one: every field goes
+* through a reader that closes over the vocabulary rather than trusting the
+* stored value.
+*
+* `compiledHeader` is the structure baseline — the header this row's own
+* (layout, recipe) compiles. It is a required parameter rather than something
+* derived inside, because a `Theme` alone does not carry the selection ids the
+* baseline needs; asking the caller for it keeps the rule single-valued.
+*
+* `navTextSize` is derived against that same baseline rather than read off
+* `header.navTextSize` (#1318 Phase 4c decision 1). It is the one nav field a
+* pre-preferences row could express only through the compiled bytes, so
+* reading the marker alone loses it — see
+* `readHeaderNavFontSizeAgainstBaseline`. `navFontRole` stays a marker read:
+* unlike size, `navLinkStyle.typography` is written by the recipe's own
+* treatment on every row, so a baseline comparison there would report the
+* treatment's default role as user intent.
+*
+* `interactionPaletteGroup` is the palette the row's resolved recipe offers,
+* and the same reasoning applies to it (#1318 Phase 4c decision 2): a row that
+* predates the palette carries its hover treatment in the compiled bytes and
+* nothing in `header.interactionPalette`. `undefined` means the caller does not
+* know which palette applies — it is not "the style has none" — and the marker
+* read stands.
+*
+* `brandPresentationCandidates` are the two headers the two presentation modes
+* produce for this row. The mode is derived by comparing the persisted `logo`
+* against both, so a row that carries no presentation block keeps having none
+* instead of being given one it has never rendered (#1318 Phase 4c decision
+* 5b). They are supplied rather than rebuilt here because they are the
+* compilation's own output, and a second construction of them would be a second
+* authority on what the modes mean — `headerBrandPresentationCandidates` builds
+* them with the real appliers.
+*/
+function readHeaderPreferences(theme, compiledHeader, interactionPaletteGroup, brandPresentationCandidates) {
+	const nav = readHeaderNavPreferences(theme);
+	const brand = headerBrandPreferencesFromTheme(theme);
+	const brandPresentation = readHeaderBrandPresentationFromBytes(theme.header, brandPresentationCandidates.recommended, brandPresentationCandidates.plain) ?? defaultHeaderBrandPresentation;
+	return {
+		brandPresentation,
+		brandDisplay: brand.brandDisplay,
+		logoSize: brand.logoSize,
+		navFontRole: nav.typography,
+		navTextSize: readHeaderNavFontSizeAgainstBaseline(theme.header, compiledHeader),
+		interactionPalette: readHeaderInteractionPaletteFromBytes(theme.header, interactionPaletteGroup) ?? nav.interactionPalette,
+		background: siteChromeBackgroundOverrideFromHeader(theme.header),
+		structure: readHeaderStructurePreferences(theme.header, brandPresentationCandidates[brandPresentation])
+	};
+}
+/**
+* Both candidates, built with the same two appliers the pipeline uses.
+*
+* There is no circularity to resolve: the only record fields that reach
+* `header.logo` are `brandDisplay` and `logoSize`, and those are read straight
+* off the persisted theme rather than derived. The structure preferences run
+* before the presentation in the named order but touch `positioning`,
+* `shrinkOnScroll` and `logoText` — never `logo` — so leaving them out here
+* cannot change either answer.
+*
+* One known over-specification, recorded rather than fixed because it changes
+* no bytes. `applyHeaderBrandPresentation` reads `positioning` when it decides
+* whether to force `shrinkOnScroll` for a display logo, and it sees the
+* *structure-adjusted* value at apply time while it sees the layout default
+* here. On a `'recommended'` row that overrides positioning to `'static'` the
+* candidate can therefore carry a forced `shrinkOnScroll` the applied header
+* will not, which makes `readHeaderStructurePreferences` emit an explicit
+* `shrinkOnScroll` where `'inherit'` would have done. The record is more
+* specific than it needs to be; the compiled bytes are identical either way,
+* because the explicit value it writes is the one the row already has. Fixing
+* it means deriving `positioning` before the candidates, which is a second
+* derivation pass for no byte change (#1318 Phase 4c review round 2, item 10).
+*/
+function headerBrandPresentationCandidates(theme, compiledBaseline, presentation) {
+	const brand = headerBrandPreferencesFromTheme(theme);
+	const withBrand = (header) => withHeaderBrandThemePreferences({
+		...theme,
+		header
+	}, brand).header;
+	return {
+		recommended: withBrand(presentation === null ? compiledBaseline : applyHeaderBrandPresentation(compiledBaseline, presentation)),
+		plain: withBrand(compiledBaseline)
+	};
+}
+function applyHeaderStructurePreferences(header, preferences) {
+	const { logoText: currentLogoText, ...headerWithoutLogoText } = header;
+	return {
+		...headerWithoutLogoText,
+		...preferences.positioning === "inherit" ? {} : { positioning: preferences.positioning },
+		...preferences.shrinkOnScroll === "inherit" ? {} : { shrinkOnScroll: preferences.shrinkOnScroll },
+		...logoTextField(currentLogoText, preferences.logoText)
+	};
+}
+function logoTextField(current, preference) {
+	if (preference === "inherit") {
+		return current === undefined ? {} : { logoText: current };
+	}
+	if (preference === "none") return {};
+	return { logoText: preference };
+}
+/**
+* The brand presentation step, which sits between the structure preferences and
+* the nav/logo/background ones because it reads `positioning` and can force
+* `shrinkOnScroll` for a display logo (`previewCompiler.ts`).
+*/
+/**
+* Writes a resolved brand presentation onto the header. Lives here rather than
+* in `previewCompiler` so the pipeline step has one definition: it sits between
+* the structure preferences and the nav/logo/background ones, and it is the
+* reason that position is load-bearing — it reads `positioning` and can force
+* `shrinkOnScroll` for a display logo that brings its own backing.
+*/
+function applyHeaderBrandPresentation(header, presentation) {
+	const shouldShrinkDisplayLogo = presentation.size === "display" && presentation.accommodation.providesBacking === true && header.positioning !== "static";
+	return {
+		...header,
+		shrinkOnScroll: shouldShrinkDisplayLogo ? true : header.shrinkOnScroll,
+		logo: {
+			fontFamily: header.logo?.fontFamily ?? "heading",
+			letterSpacing: header.logo?.letterSpacing ?? "normal",
+			gradient: header.logo?.gradient ?? false,
+			brandDisplay: presentation.display,
+			size: presentation.size,
+			accommodation: presentation.accommodation.pattern
+		}
+	};
+}
+/**
+* The preference half of the header pipeline, composed once so that no caller
+* assembles its own order. Named order, tail of the recompile:
+*
+*   structure preferences → brand presentation → brand display/logo size
+*   → nav preferences → header background override
+*
+* `brandPresentation` is data rather than a callback so the step is inspectable
+* and cannot vary by caller; `null` is "this caller has no logo context".
+*
+* The background applier is the header-only one on purpose: the header+footer
+* pair function would clobber footer intent (#1318 Correction 20).
+*/
+function applyHeaderPreferences(theme, preferences, brandPresentation) {
+	const structured = applyHeaderStructurePreferences(theme.header, preferences.structure);
+	const presented = brandPresentation === null || preferences.brandPresentation === "plain" ? structured : applyHeaderBrandPresentation(structured, brandPresentation);
+	const branded = withHeaderBrandThemePreferences({
+		...theme,
+		header: presented
+	}, {
+		brandDisplay: preferences.brandDisplay,
+		logoSize: preferences.logoSize
+	});
+	const navved = withHeaderNavThemePreferences(branded, {
+		typography: preferences.navFontRole,
+		fontSize: preferences.navTextSize,
+		interactionPalette: preferences.interactionPalette
+	});
+	return {
+		...navved,
+		header: applyHeaderBackgroundOverride(navved, navved.header, preferences.background)
+	};
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/headerRecompile.ts
+/**
+* Curated repair followed by catalogue repair — the first two steps of the
+* header compilation pipeline, in one place so no caller re-derives them.
+*/
+function resolveCuratedHeaderSelection(siteStyle, requested) {
+	const requestedLayoutChoices = headerStyleChoicesForLayout(siteStyle, requested.layoutId);
+	const curatedDefault = defaultHeaderCurationForSiteStyle(siteStyle);
+	const resolvedLayoutId = requestedLayoutChoices ? requested.layoutId : curatedDefault.selection.layoutId;
+	const curatedChoices = requestedLayoutChoices ?? curatedDefault.styles;
+	const resolution = resolveHeaderLayoutStyleSelection({
+		layoutId: resolvedLayoutId,
+		styleId: deriveNearestCompatibleHeaderStyle(requested.styleId, resolvedLayoutId, curatedChoices.map((choice) => choice.id))
+	});
+	return {
+		resolution,
+		repair: resolution.selection.layoutId === requested.layoutId && resolution.selection.styleId === requested.styleId ? { kind: "exact" } : {
+			kind: "repaired",
+			reason: requestedLayoutChoices ? "style-not-curated-for-layout" : "layout-not-curated-for-site-style"
+		}
+	};
+}
+/**
+* Curated repair → catalogue repair → recipe → interaction palette → brand
+* presentation. Everything that runs before the preference record, in one
+* place: `previewCompiler.compileHeaderDirective` and the recompile below are
+* both callers, so the middle of the pipeline has a single composition.
+*
+* `baseline` and `header` are both returned because they answer different
+* questions. `header` is what a preview wants to render. `baseline` is what
+* `readHeaderPreferences` compares the persisted bytes against for every field
+* the presentation does not touch.
+*
+* The interaction-palette preference is threaded in through `theme.header`
+* because that is where `compileHeaderLayoutStyleSelection` reads it from
+* today; 4b can pass it explicitly once the preferences column exists.
+*/
+function compileHeaderForCuratedSelection(theme, siteStyle, requested, requestedBrandPresentation, requestedInteractionPalette) {
+	const { resolution, repair: repair$1 } = resolveCuratedHeaderSelection(siteStyle, requested);
+	const interactionPalette = resolveHeaderStyleRecipe(siteStyle, resolution.style.id).interactionPalette;
+	const baseline = compileHeaderLayoutStyleSelection(theme, resolution, siteStyle, resolveInteractionPaletteRequest(theme, interactionPalette, requestedInteractionPalette));
+	const brandPresentation = requestedBrandPresentation.kind === "apply-logo-context" ? resolveHeaderBrandPresentationForLayout({
+		layout: resolution.layout,
+		logo: requestedBrandPresentation.logo
+	}) : null;
+	return {
+		baseline,
+		header: brandPresentation === null ? baseline : applyHeaderBrandPresentation(baseline, brandPresentation),
+		brandPresentation,
+		interactionPalette,
+		resolution,
+		repair: repair$1
+	};
+}
+/**
+* The bytes-derived answer wins when the recipe offers a palette at all;
+* otherwise the marker field on the theme stands, which is what every caller
+* that holds no preference record has always used.
+*/
+function resolveInteractionPaletteRequest(theme, group, request) {
+	if (request.kind === "preference") return request.preference;
+	return readHeaderInteractionPaletteFromBytes(theme.header, group) ?? readHeaderNavPreferences(theme).interactionPalette;
+}
+/**
+* The whole header pipeline, in one named function so 4b, 4c and 4d cannot
+* drift into three orders (#1318 Phase 4):
+*
+*   curated repair → catalogue repair → recipe → layout defaults
+*   → interaction palette → structure preferences → brand presentation
+*   → nav/logo/background preferences
+*/
+function recompileSiteChromeHeader(input) {
+	return applyPreferencesToCompiledHeader(input.theme, compileHeaderForCuratedSelection(input.theme, input.siteStyle, input.requested, input.brandPresentation, {
+		kind: "preference",
+		preference: input.preferences.interactionPalette
+	}), input.preferences);
+}
+/**
+* The preferences run against `baseline`, not `header`: the brand presentation
+* belongs *after* the structure preferences in the named order, and
+* `applyHeaderPreferences` applies it there. Starting from `header` would apply
+* it twice and put the earlier copy in the wrong place.
+*/
+function applyPreferencesToCompiledHeader(theme, compiled, preferences) {
+	const applied = applyHeaderPreferences({
+		...theme,
+		header: compiled.baseline
+	}, preferences, compiled.brandPresentation);
+	return {
+		header: applied.header,
+		resolution: compiled.resolution,
+		repair: compiled.repair
+	};
+}
+/**
+* The read-then-recompile round trip: derive the row's intent from its own
+* persisted bytes, then rebuild the header from that intent. On a row whose
+* bytes are compiler output this returns the persisted header unchanged, which
+* is what the Phase 4c divergence report measures.
+*/
+function recompileSiteChromeHeaderFromPersistedIntent(theme, siteStyle, requested, brandPresentation) {
+	const compiled = compileHeaderForCuratedSelection(theme, siteStyle, requested, brandPresentation, { kind: "derive-from-persisted-bytes" });
+	const candidates = headerBrandPresentationCandidates(theme, compiled.baseline, compiled.brandPresentation);
+	const preferences = readHeaderPreferences(theme, compiled.header, compiled.interactionPalette, candidates);
+	return {
+		recompiled: applyPreferencesToCompiledHeader(theme, compiled, preferences),
+		preferences,
+		interactionPaletteBytes: classifyHeaderInteractionPaletteBytes(theme.header, compiled.interactionPalette),
+		brandPresentationBytes: classifyHeaderBrandPresentationBytes(theme.header, candidates.recommended, candidates.plain)
+	};
+}
+
 //#endregion
 //#region ../theme-core/src/site-styles/runtimeBackgroundResolution.ts
 function parseCanonicalRuntimeBackground(content) {
@@ -23010,43 +24248,56 @@ function isCycleableDesignOption(option) {
 //#endregion
 //#region ../theme-core/src/site-styles/previewCompiler.ts
 const previewCustomizePurpose = "preview-customize";
+/**
+* "Leave the header as the user last chose it" (#1318 Phase 4d).
+*
+* Before 4d this returned the caller's bytes verbatim, which was a fourth path
+* by which a hand-written header reached persistence. It now recompiles from
+* the row's stored selection and preferences — the stored record when the
+* caller holds one, and the row's own bytes read back through the Phase 4a
+* reader while the Phase 4c backfill is outstanding. On a row whose bytes are
+* compiler output this returns the persisted header unchanged, which is what
+* the divergence report measures; on a row whose bytes diverge, the intent is
+* what survives, which is the point of the phase.
+*/
+function compilePreservedHeaderDirective(directive, input) {
+	const recompiled = directive.preferences === null ? recompileSiteChromeHeaderFromPersistedIntent(directive.persistedTheme, input.siteStyle, input.currentSelection, directive.brandPresentation).recompiled : recompileSiteChromeHeader({
+		theme: directive.persistedTheme,
+		siteStyle: input.siteStyle,
+		requested: input.currentSelection,
+		preferences: directive.preferences,
+		brandPresentation: directive.brandPresentation
+	});
+	return {
+		header: recompiled.header,
+		brandPresentation: null,
+		resolvedHeaderSelection: recompiled.resolution.selection,
+		warning: recompiled.repair.kind === "exact" ? null : {
+			kind: "repaired-header-selection",
+			requested: input.currentSelection,
+			resolved: recompiled.resolution.selection,
+			reason: recompiled.repair.reason
+		}
+	};
+}
 function compileHeaderDirective(input) {
 	if (input.directive.kind === "preserve") {
-		return {
-			header: input.directive.header,
-			brandPresentation: null,
-			resolvedHeaderSelection: input.currentSelection,
-			warning: null
-		};
+		return compilePreservedHeaderDirective(input.directive, input);
 	}
 	const requested = input.directive.selection;
-	const requestedLayoutChoices = headerStyleChoicesForLayout(input.siteStyle, requested.layoutId);
-	const curatedDefault = defaultHeaderSelectionForSiteStyle(input.siteStyle);
-	const resolvedLayoutId = requestedLayoutChoices ? requested.layoutId : curatedDefault.layoutId;
-	const curatedChoices = requestedLayoutChoices ?? headerStyleChoicesForLayout(input.siteStyle, curatedDefault.layoutId);
-	if (!curatedChoices) {
-		throw new Error(`Site style ${input.siteStyle.id} has invalid header curation`);
-	}
-	const resolvedStyleId = deriveNearestCompatibleHeaderStyle(requested.styleId, resolvedLayoutId, curatedChoices.map((choice) => choice.id));
-	const resolution = resolveHeaderLayoutStyleSelection({
-		layoutId: resolvedLayoutId,
-		styleId: resolvedStyleId
+	const { header, brandPresentation, resolution, repair: repair$1 } = compileHeaderForCuratedSelection(input.theme, input.siteStyle, requested, input.directive.brandPresentation, {
+		kind: "preference",
+		preference: readHeaderNavPreferences(input.theme).interactionPalette
 	});
-	const header = compileHeaderLayoutStyleSelection(input.theme, resolution, input.siteStyle);
-	const brandPresentation = input.directive.brandPresentation.kind === "apply-logo-context" ? resolveHeaderBrandPresentationForLayout({
-		layout: resolution.layout,
-		logo: input.directive.brandPresentation.logo
-	}) : null;
-	const headerWithBrandPresentation = brandPresentation !== null ? applyHeaderBrandPresentation(header, brandPresentation) : header;
 	return {
-		header: headerWithBrandPresentation,
+		header,
 		brandPresentation,
 		resolvedHeaderSelection: resolution.selection,
-		warning: resolution.selection.layoutId === requested.layoutId && resolution.selection.styleId === requested.styleId ? null : {
+		warning: repair$1.kind === "exact" ? null : {
 			kind: "repaired-header-selection",
 			requested,
 			resolved: resolution.selection,
-			reason: requestedLayoutChoices ? "style-not-curated-for-layout" : "layout-not-curated-for-site-style"
+			reason: repair$1.reason
 		}
 	};
 }
@@ -23080,21 +24331,6 @@ function compileIncrementalFooter(input) {
 		resolvedFooterLookId: result.selectedLookId
 	};
 }
-function applyHeaderBrandPresentation(header, presentation) {
-	const shouldShrinkDisplayLogo = presentation.size === "display" && presentation.accommodation.providesBacking === true && header.positioning !== "static";
-	return {
-		...header,
-		shrinkOnScroll: shouldShrinkDisplayLogo ? true : header.shrinkOnScroll,
-		logo: {
-			fontFamily: header.logo?.fontFamily ?? "heading",
-			letterSpacing: header.logo?.letterSpacing ?? "normal",
-			gradient: header.logo?.gradient ?? false,
-			brandDisplay: presentation.display,
-			size: presentation.size,
-			accommodation: presentation.accommodation.pattern
-		}
-	};
-}
 function applyFooterBrandPresentation(footer, presentation) {
 	const size = footerLogoSizeFromBrandPresentation(presentation.size);
 	return {
@@ -24170,6 +25406,123 @@ function runGeneratedPageDesignPipeline(input) {
 	};
 }
 
+//#endregion
+//#region ../theme-core/src/site-styles/headerPreferencesPersistence.ts
+const backgroundColorTokenSchema = z.unknown().transform((value, ctx) => {
+	const token = parseSiteChromeBackgroundColorToken(value);
+	if (token === null) {
+		ctx.addIssue({
+			code: "custom",
+			message: "Unknown site chrome background colour token"
+		});
+		return z.NEVER;
+	}
+	return token;
+});
+const backgroundOverrideSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("default") }).strict(), z.object({
+	kind: z.literal("color"),
+	token: backgroundColorTokenSchema
+}).strict()]);
+const logoTextIntentSchema = z.object({
+	mobileMaxWidth: z.enum([
+		"xs",
+		"sm",
+		"md"
+	]).optional(),
+	mobileWrapLines: z.union([z.literal(1), z.literal(2)]).optional(),
+	hideOnShrink: z.boolean().optional()
+}).strict();
+const structureSchema = z.object({
+	positioning: z.union([z.literal("inherit"), z.enum(headerPositioningValues)]),
+	shrinkOnScroll: z.union([z.literal("inherit"), z.boolean()]),
+	logoText: z.union([
+		z.literal("inherit"),
+		z.literal("none"),
+		logoTextIntentSchema
+	])
+}).strict();
+const headerPreferencesShape = {
+	brandPresentation: z.enum(headerBrandPresentationValues),
+	brandDisplay: z.enum(brandDisplayModeValues),
+	logoSize: z.enum(logoSizePolicyValues),
+	navFontRole: z.enum(headerNavTypographyPreferenceValues),
+	navTextSize: z.enum(headerNavFontSizePreferenceValues),
+	interactionPalette: z.union([z.literal("recommended"), z.enum(headerInteractionPaletteValues)]),
+	background: backgroundOverrideSchema,
+	structure: structureSchema
+};
+/**
+* The persisted shape of `HeaderPreferences`, closed at every field.
+*
+* `.strict()` throughout is deliberate: an unknown key in the stored blob means
+* the writer knew about a field this reader does not, and silently dropping it
+* would let a save round-trip away someone else's intent. Every field is
+* required for the same reason a default would be a hidden authority: a stored
+* record that omits one is not a record this reader may complete.
+*/
+const headerPreferencesSchema = z.object(headerPreferencesShape).strict();
+/** Only controls the client can edit may cross the write boundary. */
+const headerPreferencesWireSchema = z.object(headerPreferencesShape).omit({
+	brandPresentation: true,
+	structure: true
+}).strict();
+function parsePersistedHeaderPreferences(value) {
+	if (value === null || value === undefined) return { kind: "absent" };
+	const parsed = headerPreferencesSchema.safeParse(value);
+	if (parsed.success) return {
+		kind: "present",
+		preferences: parsed.data
+	};
+	return {
+		kind: "invalid",
+		issues: parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+	};
+}
+
+//#endregion
+//#region ../theme-core/src/site-styles/headerBytesComparison.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Structural diff by JSON path. Values are compared through
+* `JSON.stringify`, so a key present with the value `undefined` and an absent
+* key read as the same thing — which is what `jsonb` does to them anyway
+* (#1318 Correction 5).
+*/
+function diffJsonPaths(left, right, path$2 = "") {
+	if (isPlainObject(left) && isPlainObject(right)) {
+		const keys = [...new Set([...Object.keys(left), ...Object.keys(right)])].sort();
+		return keys.flatMap((key) => diffJsonPaths(left[key], right[key], path$2 ? `${path$2}.${key}` : key));
+	}
+	if (JSON.stringify(left) === JSON.stringify(right)) return [];
+	return [{
+		path: path$2,
+		left,
+		right
+	}];
+}
+function roundTrip(header) {
+	return JSON.parse(JSON.stringify(header));
+}
+/**
+* The Phase 4b equality assertion: does the header a client compiled match the
+* one the server compiles from the same `(selection, preferences)`?
+*
+* Both sides go through a JSON round trip first, because the persisted form is
+* `jsonb` and an in-memory `ctaVariant: undefined` is not a difference the
+* database could ever store (#1318 Correction 5). Comparing the in-memory
+* objects directly would report a mismatch that no save could produce.
+*/
+function compareCompiledHeaders(left, right) {
+	const diffs = diffJsonPaths(roundTrip(left), roundTrip(right));
+	return diffs.length === 0 ? { kind: "equal" } : {
+		kind: "different",
+		diffs,
+		differingPaths: diffs.map((diff) => diff.path)
+	};
+}
+
 //#endregion
 //#region ../theme-core/src/site-styles/headerOpeningForeground.ts
 function headerStyleAvailability(recipe, context) {
@@ -24609,276 +25962,6 @@ function boundaryPinsEqual(left, right) {
 	return left.boundaryId === right.boundaryId && left.previousBlockId === right.previousBlockId && left.nextBlockId === right.nextBlockId && boundaryOptionIdForTreatment(left.choice.value) === boundaryOptionIdForTreatment(right.choice.value);
 }
 
-//#endregion
-//#region ../theme-core/src/site-styles/siteChromeBackgrounds.ts
-const siteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceColorTokenNames);
-const quickSiteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceQuickColorTokenNames);
-const advancedSiteChromeBackgroundColorTokens = siteChromeBackgroundColorTokens.filter((token) => !quickSiteChromeBackgroundColorTokens.includes(token));
-const defaultSiteChromeBackgroundOverride = { kind: "default" };
-function defaultSiteChromeBackgroundPreferences() {
-	return {
-		header: defaultSiteChromeBackgroundOverride,
-		footer: defaultSiteChromeBackgroundOverride
-	};
-}
-function parseSiteChromeBackgroundColorToken(value) {
-	const token = parseBackgroundAppearanceColorToken(value);
-	return token ? token : null;
-}
-function siteChromeBackgroundPreferencesFromTheme(theme) {
-	if (!theme) return defaultSiteChromeBackgroundPreferences();
-	return {
-		header: theme.header ? siteChromeBackgroundOverrideFromHeader(theme.header) : defaultSiteChromeBackgroundOverride,
-		footer: theme.footer ? siteChromeBackgroundOverrideFromFooter(theme.footer) : defaultSiteChromeBackgroundOverride
-	};
-}
-function applySiteChromeBackgroundPreferences(theme, preferences) {
-	return {
-		...theme,
-		header: applyHeaderBackgroundOverride(theme, theme.header, preferences.header),
-		footer: applyFooterBackgroundOverride(theme, theme.footer, preferences.footer)
-	};
-}
-function canCustomizeSiteChromeBackground(theme, surface$1) {
-	if (surface$1 === "footer") return true;
-	const header = theme?.header;
-	if (!header) return false;
-	const navContainerType = header.navContainer?.type ?? "none";
-	return header.variant !== "floating" && navContainerType !== "glass" && navContainerType !== "pill";
-}
-function siteChromeBackgroundOverrideLabel(override) {
-	switch (override.kind) {
-		case "default": return "Default";
-		case "color": return formatSiteChromeBackgroundTokenLabel(override.token);
-	}
-}
-function formatSiteChromeBackgroundTokenLabel(token) {
-	return String(token).replace(/-/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
-}
-function siteChromeBackgroundOverrideEquals(left, right) {
-	return left.kind === right.kind && (left.kind === "default" || right.kind === "color" && left.token === right.token);
-}
-function cycleSiteChromeBackgroundOverride(current, direction) {
-	const fallback = direction === "next" ? quickSiteChromeBackgroundColorTokens[0] : quickSiteChromeBackgroundColorTokens[quickSiteChromeBackgroundColorTokens.length - 1];
-	if (!fallback) return defaultSiteChromeBackgroundOverride;
-	if (current.kind === "default") {
-		return {
-			kind: "color",
-			token: fallback
-		};
-	}
-	const currentIndex = quickSiteChromeBackgroundColorTokens.indexOf(current.token);
-	if (currentIndex === -1) {
-		return {
-			kind: "color",
-			token: fallback
-		};
-	}
-	const nextIndex = direction === "next" ? (currentIndex + 1) % quickSiteChromeBackgroundColorTokens.length : currentIndex === 0 ? quickSiteChromeBackgroundColorTokens.length - 1 : currentIndex - 1;
-	const token = requiredQuickSiteChromeBackgroundColorToken(nextIndex);
-	return {
-		kind: "color",
-		token
-	};
-}
-function siteChromeBackgroundOverrideFromHeader(header) {
-	return siteChromeBackgroundOverrideFromBackground(header.background);
-}
-function siteChromeBackgroundOverrideFromFooter(footer) {
-	return siteChromeBackgroundOverrideFromBackground(footer.background);
-}
-function siteChromeBackgroundOverrideFromBackground(background) {
-	if (background?.contentOwner !== siteChromeBackgroundOverrideOwner || background.type !== "color") {
-		return defaultSiteChromeBackgroundOverride;
-	}
-	const token = parseSiteChromeBackgroundColorToken(background.color);
-	return token ? {
-		kind: "color",
-		token
-	} : defaultSiteChromeBackgroundOverride;
-}
-function applyHeaderBackgroundOverride(theme, header, override) {
-	if (override.kind === "default") return header;
-	const background = siteChromeColorBackground(override.token);
-	const foreground = resolveChromeForegroundToken(theme, background);
-	return {
-		...header,
-		background: {
-			...background,
-			textColor: foreground
-		},
-		textColor: foreground,
-		navColor: foreground,
-		...header.navLinkStyle ? { navLinkStyle: {
-			...header.navLinkStyle,
-			colorToken: foreground
-		} } : {}
-	};
-}
-function applyFooterBackgroundOverride(theme, footer, override) {
-	if (override.kind === "default") return footer;
-	const background = siteChromeColorBackground(override.token);
-	const foreground = resolveChromeForegroundToken(theme, background);
-	return {
-		...footer,
-		background: {
-			...background,
-			textColor: foreground
-		},
-		navColor: foreground,
-		...footer.navLinkStyle ? { navLinkStyle: {
-			...footer.navLinkStyle,
-			colorToken: foreground
-		} } : {},
-		...footer.bottomTextLinkStyle ? { bottomTextLinkStyle: {
-			...footer.bottomTextLinkStyle,
-			colorToken: foreground
-		} } : {},
-		...footer.bottomBar ? { bottomBar: {
-			...footer.bottomBar,
-			textColor: foreground
-		} } : {}
-	};
-}
-function resolveChromeForegroundToken(theme, background) {
-	const resolved = resolveSurfaceForeground(background, expandPalette(theme.palette));
-	if (resolved.kind === "unknown") {
-		throw new Error(`Site chrome background "${background?.type === "color" ? background.color ?? "unknown" : "unknown"}" has no resolvable AA foreground; the theme palette is incomplete`);
-	}
-	return resolved.roles.text;
-}
-function siteChromeColorBackground(color) {
-	return {
-		type: "color",
-		contentOwner: siteChromeBackgroundOverrideOwner,
-		color
-	};
-}
-function toSiteChromeBackgroundColorTokens(tokenNames) {
-	return tokenNames.flatMap((name) => {
-		const token = parseSiteChromeBackgroundColorToken(name);
-		return token ? [token] : [];
-	});
-}
-function requiredQuickSiteChromeBackgroundColorToken(index) {
-	const token = quickSiteChromeBackgroundColorTokens[index];
-	if (!token) {
-		throw new Error(`Missing quick site chrome background token at index ${index}`);
-	}
-	return token;
-}
-
-//#endregion
-//#region ../theme-core/src/site-styles/siteChromeNavPreferences.ts
-const headerNavTypographyPreferenceValues = [
-	"inherit",
-	"body",
-	"heading"
-];
-const headerNavFontSizePreferenceValues = [
-	"inherit",
-	"sm",
-	"base",
-	"lg",
-	"xl"
-];
-const headerNavTypographyOptions = [
-	{
-		value: "inherit",
-		label: "Default"
-	},
-	{
-		value: "body",
-		label: "Body"
-	},
-	{
-		value: "heading",
-		label: "Heading"
-	}
-];
-const headerNavFontSizeOptions = [
-	{
-		value: "inherit",
-		label: "Default"
-	},
-	{
-		value: "sm",
-		label: "Small"
-	},
-	{
-		value: "base",
-		label: "Regular"
-	},
-	{
-		value: "lg",
-		label: "Large"
-	},
-	{
-		value: "xl",
-		label: "Huge"
-	}
-];
-const defaultHeaderNavPreferences = {
-	typography: "inherit",
-	fontSize: "inherit",
-	interactionPalette: "recommended"
-};
-function readHeaderNavPreferences(theme) {
-	const typography = theme?.header?.navFontRole;
-	const fontSize = theme?.header?.navTextSize;
-	const interactionPalette = theme?.header?.interactionPalette ?? "recommended";
-	return typography === "body" || typography === "heading" ? {
-		typography,
-		fontSize: readHeaderNavFontSizePreference(fontSize),
-		interactionPalette
-	} : {
-		...defaultHeaderNavPreferences,
-		fontSize: readHeaderNavFontSizePreference(fontSize),
-		interactionPalette
-	};
-}
-function headerNavPreferencesEqual(left, right) {
-	return left.typography === right.typography && left.fontSize === right.fontSize && left.interactionPalette === right.interactionPalette;
-}
-function withHeaderNavThemePreferences(theme, preferences) {
-	const { navFontRole: _navFontRole, navTextSize: _navTextSize, interactionPalette: _interactionPalette, ...headerWithoutPreference } = theme.header;
-	const nextHeader = {
-		...headerWithoutPreference,
-		...preferences.typography === "inherit" ? {} : { navFontRole: preferences.typography },
-		...preferences.fontSize === "inherit" ? {} : { navTextSize: preferences.fontSize },
-		...preferences.interactionPalette === "recommended" ? {} : { interactionPalette: preferences.interactionPalette }
-	};
-	return {
-		...theme,
-		header: nextHeader
-	};
-}
-/**
-* Applies the user's nav font-role/size overrides on top of a style-resolved
-* nav link style. This is where the precedence contract lands:
-*
-* - The nav typography TREATMENT (case/tracking identity: plain / heading /
-*   quiet-caps / brand-caps) is ALWAYS owned by the active header style and is
-*   baked into `style` before this call (see `applyNavTypography` in
-*   headerLayoutStyles.ts).
-* - Each treatment resolves through a DEFAULT font role: `heading` resolves
-*   through the heading role; `plain` / `quiet-caps` / `brand-caps` resolve
-*   through the body role.
-* - The user's `navFontRole` (surfaced here as `preferences.typography`) only
-*   overrides which font ROLE the treatment resolves through. It never changes
-*   the treatment. `'inherit'` keeps the treatment's default role.
-*/
-function mergeHeaderNavTypographyPreference(style, preferences) {
-	return preferences.typography === "inherit" && preferences.fontSize === "inherit" ? style : {
-		...style,
-		...preferences.typography === "inherit" ? {} : { typography: preferences.typography },
-		...preferences.fontSize === "inherit" ? {} : { textSize: preferences.fontSize }
-	};
-}
-function readHeaderNavFontSizePreference(value) {
-	return value === "sm" || value === "base" || value === "lg" || value === "xl" ? value : "inherit";
-}
-
 //#endregion
 //#region ../theme-core/src/site-styles/tokenRecipes.ts
 const themeTokenRecipeOptions = {
@@ -24994,24 +26077,24 @@ function normalizeHex$1(value) {
 	const blue = triplet.charAt(2);
 	return `#${red}${red}${green}${green}${blue}${blue}`;
 }
-function collectDifferences(before, after, path$1, differences) {
+function collectDifferences(before, after, path$2, differences) {
 	if (Object.is(before, after)) return;
 	if (Array.isArray(before) && Array.isArray(after)) {
 		const sharedLength = Math.min(before.length, after.length);
 		for (let index = 0; index < sharedLength; index += 1) {
-			collectDifferences(before[index], after[index], `${path$1}[${index}]`, differences);
+			collectDifferences(before[index], after[index], `${path$2}[${index}]`, differences);
 		}
 		for (let index = sharedLength; index < before.length; index += 1) {
 			differences.push({
 				kind: "missing",
-				path: `${path$1}[${index}]`,
+				path: `${path$2}[${index}]`,
 				before: before[index]
 			});
 		}
 		for (let index = sharedLength; index < after.length; index += 1) {
 			differences.push({
 				kind: "extra",
-				path: `${path$1}[${index}]`,
+				path: `${path$2}[${index}]`,
 				after: after[index]
 			});
 		}
@@ -25022,7 +26105,7 @@ function collectDifferences(before, after, path$1, differences) {
 		const afterKeys = new Set(Object.keys(after));
 		const keys = [...new Set([...beforeKeys, ...afterKeys])].sort();
 		for (const key of keys) {
-			const childPath = `${path$1}.${key}`;
+			const childPath = `${path$2}.${key}`;
 			if (!afterKeys.has(key)) {
 				differences.push({
 					kind: "missing",
@@ -25045,7 +26128,7 @@ function collectDifferences(before, after, path$1, differences) {
 	}
 	differences.push({
 		kind: "changed",
-		path: path$1,
+		path: path$2,
 		before,
 		after
 	});
@@ -25216,8 +26299,8 @@ const sdkConfigureBookingVerticalResponseSchema = sdkCommandApplicationResultSch
 function isRecord$8(value) {
 	return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function pullSchemaForRequest(path$1) {
-	switch (path$1) {
+function pullSchemaForRequest(path$2) {
+	switch (path$2) {
 		case "/pull/entries/all": return sdkPullEntriesAllResponseSchema;
 		case "/pull/entries": return sdkPullEntriesResponseSchema;
 		case "/pull/pages": return sdkPullPagesResponseSchema;
@@ -25229,12 +26312,12 @@ function pullSchemaForRequest(path$1) {
 		case "/pull/venues": return sdkPullVenuesResponseSchema;
 		case "/pull/event-categories": return sdkPullEventCategoriesResponseSchema;
 		case "/pull/events": return sdkPullEventsResponseSchema;
-		default: return /^\/pull\/entries\/[^/]+$/.test(path$1) ? sdkPullEntriesByTypeResponseSchema : undefined;
+		default: return /^\/pull\/entries\/[^/]+$/.test(path$2) ? sdkPullEntriesByTypeResponseSchema : undefined;
 	}
 }
-function rootMutationSchema(method, path$1, body) {
+function rootMutationSchema(method, path$2, body) {
 	if (method === "POST") {
-		switch (path$1) {
+		switch (path$2) {
 			case "/entries": return isRecord$8(body) && body.publication === "publish" ? sdkUpsertEntryPublishResponseSchema : sdkUpsertEntryDraftResponseSchema;
 			case "/pages": return isRecord$8(body) && body.publication === "publish" ? sdkUpsertPagePublishResponseSchema : sdkUpsertPageDraftResponseSchema;
 			case "/navigation": return sdkUpsertNavigationMenuResponseSchema;
@@ -25247,11 +26330,11 @@ function rootMutationSchema(method, path$1, body) {
 			case "/footer": return sdkUpsertFooterResponseSchema;
 		}
 	}
-	if (method === "PATCH" && path$1 === "/settings") return sdkUpsertSettingsResponseSchema;
-	if (method === "POST" && path$1 === "/settings/booking/vertical") return sdkConfigureBookingVerticalResponseSchema;
+	if (method === "PATCH" && path$2 === "/settings") return sdkUpsertSettingsResponseSchema;
+	if (method === "POST" && path$2 === "/settings/booking/vertical") return sdkConfigureBookingVerticalResponseSchema;
 	return undefined;
 }
-function isDeleteMutationPath(path$1) {
+function isDeleteMutationPath(path$2) {
 	return [
 		/^\/entries\/[^/]+\/[^/]+$/,
 		/^\/pages\/[^/]+$/,
@@ -25261,35 +26344,42 @@ function isDeleteMutationPath(path$1) {
 		/^\/venues\/[^/]+$/,
 		/^\/event-categories\/[^/]+$/,
 		/^\/events\/[^/]+$/
-	].some((pattern) => pattern.test(path$1));
+	].some((pattern) => pattern.test(path$2));
 }
-function nestedMutationSchema(method, path$1) {
-	if (method === "POST" && /^\/pages\/[^/]+\/blocks$/.test(path$1)) return sdkUpsertBlockResponseSchema;
-	if (method === "POST" && /^\/pages\/[^/]+\/blocks\/reorder$/.test(path$1)) return sdkReorderResponseSchema;
-	if (method === "PATCH" && /^\/pages\/[^/]+\/blocks\/[^/]+$/.test(path$1)) return sdkPatchPageBlockResponseSchema;
-	if (method === "POST" && /^\/entries\/[^/]+\/[^/]+\/(publish|unpublish)$/.test(path$1)) {
+function nestedMutationSchema(method, path$2) {
+	if (method === "POST" && /^\/pages\/[^/]+\/blocks$/.test(path$2)) return sdkUpsertBlockResponseSchema;
+	if (method === "POST" && /^\/pages\/[^/]+\/blocks\/reorder$/.test(path$2)) return sdkReorderResponseSchema;
+	if (method === "PATCH" && /^\/pages\/[^/]+\/blocks\/[^/]+$/.test(path$2)) return sdkPatchPageBlockResponseSchema;
+	if (method === "POST" && /^\/entries\/[^/]+\/[^/]+\/(publish|unpublish)$/.test(path$2)) {
 		return sdkCommandApplicationResultSchema(sdkUpsertEntryDraftResponseSchema.shape.value);
 	}
-	if (method === "POST" && /^\/pages\/[^/]+\/(publish|unpublish)$/.test(path$1)) {
+	if (method === "POST" && /^\/pages\/[^/]+\/(publish|unpublish)$/.test(path$2)) {
 		return sdkCommandApplicationResultSchema(sdkUpsertPageDraftResponseSchema.shape.value);
 	}
-	if (method === "DELETE" && isDeleteMutationPath(path$1)) return sdkDeleteResponseSchema;
+	if (method === "DELETE" && isDeleteMutationPath(path$2)) return sdkDeleteResponseSchema;
 	return undefined;
 }
-function occurrenceResponseSchema(method, path$1) {
+function occurrenceResponseSchema(method, path$2) {
 	const collection = /^\/events\/[^/]+\/runs\/[^/]+\/occurrences$/;
 	const member = /^\/events\/[^/]+\/runs\/[^/]+\/occurrences\/[^/]+$/;
-	if (method === "GET" && collection.test(path$1)) return sdkListEventOccurrencesResponseSchema;
-	if (method === "POST" && collection.test(path$1)) return sdkEventOccurrenceResponseSchema;
-	if (method === "PATCH" && member.test(path$1)) return sdkEventOccurrenceResponseSchema;
-	if (method === "DELETE" && member.test(path$1)) return sdkDeleteEventOccurrenceResponseSchema;
-	return method === "POST" && /^\/events\/[^/]+\/runs\/[^/]+\/occurrences\/[^/]+\/cancel$/.test(path$1) ? sdkEventOccurrenceResponseSchema : undefined;
+	if (method === "GET" && collection.test(path$2)) return sdkListEventOccurrencesResponseSchema;
+	if (method === "POST" && collection.test(path$2)) return sdkEventOccurrenceResponseSchema;
+	if (method === "PATCH" && member.test(path$2)) return sdkEventOccurrenceResponseSchema;
+	if (method === "DELETE" && member.test(path$2)) return sdkDeleteEventOccurrenceResponseSchema;
+	return method === "POST" && /^\/events\/[^/]+\/runs\/[^/]+\/occurrences\/[^/]+\/cancel$/.test(path$2) ? sdkEventOccurrenceResponseSchema : undefined;
+}
+function mediaResponseSchema(method, path$2) {
+	if (method === "GET" && path$2 === "/media") return sdkMediaListResponseSchema;
+	if (method === "GET" && /^\/media\/[^/]+\/download$/.test(path$2)) return sdkMediaDownloadResponseSchema;
+	if (method === "POST" && /^\/media\/[^/]+\/delete-preview$/.test(path$2)) return sdkMediaDeletePreviewResponseSchema;
+	if (method === "DELETE" && /^\/media\/[^/]+$/.test(path$2)) return sdkMediaDeleteApplyResponseSchema;
+	return undefined;
 }
-function schemaForManagementRequest(method, path$1, body) {
+function schemaForManagementRequest(method, path$2, body) {
 	if (method === "GET") {
-		return pullSchemaForRequest(path$1) ?? occurrenceResponseSchema(method, path$1);
+		return pullSchemaForRequest(path$2) ?? occurrenceResponseSchema(method, path$2) ?? mediaResponseSchema(method, path$2);
 	}
-	return rootMutationSchema(method, path$1, body) ?? occurrenceResponseSchema(method, path$1) ?? nestedMutationSchema(method, path$1);
+	return rootMutationSchema(method, path$2, body) ?? occurrenceResponseSchema(method, path$2) ?? mediaResponseSchema(method, path$2) ?? nestedMutationSchema(method, path$2);
 }
 function validateManagementResponse(value, schema) {
 	const parsed = schema.safeParse(value);
@@ -25444,10 +26534,10 @@ async function readApiResponse(response, requestInfo, options = {}) {
 	}
 	return envelope;
 }
-function requestUrl(baseUrl, path$1, params) {
-	if (!params || Object.keys(params).length === 0) return `${baseUrl}${path$1}`;
+function requestUrl(baseUrl, path$2, params) {
+	if (!params || Object.keys(params).length === 0) return `${baseUrl}${path$2}`;
 	const query = new URLSearchParams(params).toString();
-	return `${baseUrl}${path$1}?${query}`;
+	return `${baseUrl}${path$2}?${query}`;
 }
 function requestFetchOptions(config, method, body) {
 	const options = {
@@ -25461,10 +26551,10 @@ function requestFetchOptions(config, method, body) {
 	if (body !== undefined && method !== "GET") options.body = JSON.stringify(body);
 	return options;
 }
-async function fetchManagementResponse(config, method, path$1, url, baseUrl, options) {
+async function fetchManagementResponse(config, method, path$2, url, baseUrl, options) {
 	const requestInfo = buildRequestInfo({
 		method,
-		path: path$1,
+		path: path$2,
 		url,
 		baseUrl,
 		dashboardUrl: config.dashboardUrl,
@@ -25490,12 +26580,12 @@ function throwApiError(response, json, requestInfo) {
 	}
 	throw new ManagementApiError(`Request failed with status ${response.status}`, "sdk:http-error", undefined, response.status, requestInfo);
 }
-async function requestWithConfig(config, method, path$1, options) {
+async function requestWithConfig(config, method, path$2, options) {
 	const baseUrl = `${config.dashboardUrl}/api/sdk/${config.siteId}`;
-	const url = requestUrl(baseUrl, path$1, options?.params);
+	const url = requestUrl(baseUrl, path$2, options?.params);
 	const fetchOptions = requestFetchOptions(config, method, options?.body);
-	const { response, requestInfo } = await fetchManagementResponse(config, method, path$1, url, baseUrl, fetchOptions);
-	const responseSchema = options?.responseSchema ?? schemaForManagementRequest(method, path$1, options?.body);
+	const { response, requestInfo } = await fetchManagementResponse(config, method, path$2, url, baseUrl, fetchOptions);
+	const responseSchema = options?.responseSchema ?? schemaForManagementRequest(method, path$2, options?.body);
 	const json = responseSchema ? await readApiResponse(response, requestInfo, { invalidOkResponse: true }) : await readApiResponse(response, requestInfo, { allowNonJsonOk: true });
 	if (!json) return undefined;
 	throwApiError(response, json, requestInfo);
@@ -25503,38 +26593,38 @@ async function requestWithConfig(config, method, path$1, options) {
 }
 function createHttpClient(config) {
 	return {
-		async get(path$1, params) {
-			return requestWithConfig(config, "GET", path$1, { params });
+		async get(path$2, params) {
+			return requestWithConfig(config, "GET", path$2, { params });
 		},
-		async post(path$1, body) {
-			return requestWithConfig(config, "POST", path$1, { body });
+		async post(path$2, body) {
+			return requestWithConfig(config, "POST", path$2, { body });
 		},
-		async patch(path$1, body) {
-			return requestWithConfig(config, "PATCH", path$1, { body });
+		async patch(path$2, body) {
+			return requestWithConfig(config, "PATCH", path$2, { body });
 		},
-		async delete(path$1, body) {
-			return requestWithConfig(config, "DELETE", path$1, { body });
+		async delete(path$2, body) {
+			return requestWithConfig(config, "DELETE", path$2, { body });
 		},
-		async getValidated(path$1, schema, params) {
-			return requestWithConfig(config, "GET", path$1, {
+		async getValidated(path$2, schema, params) {
+			return requestWithConfig(config, "GET", path$2, {
 				params,
 				responseSchema: schema
 			});
 		},
-		async postValidated(path$1, schema, body) {
-			return requestWithConfig(config, "POST", path$1, {
+		async postValidated(path$2, schema, body) {
+			return requestWithConfig(config, "POST", path$2, {
 				body,
 				responseSchema: schema
 			});
 		},
-		async patchValidated(path$1, schema, body) {
-			return requestWithConfig(config, "PATCH", path$1, {
+		async patchValidated(path$2, schema, body) {
+			return requestWithConfig(config, "PATCH", path$2, {
 				body,
 				responseSchema: schema
 			});
 		},
-		async deleteValidated(path$1, schema, body) {
-			return requestWithConfig(config, "DELETE", path$1, {
+		async deleteValidated(path$2, schema, body) {
+			return requestWithConfig(config, "DELETE", path$2, {
 				body,
 				responseSchema: schema
 			});
@@ -26149,17 +27239,51 @@ function createIdentifiersOperations(http) {
 
 //#endregion
 //#region ../management-client/src/media.ts
+const productionMediaOperationsDeps = {
+	createHttpClient,
+	fetch
+};
 /**
 * Create media operations for the management client.
 * Uses direct-to-storage signed upload URLs for file uploads.
 */
-function createMediaOperations(config) {
+function createMediaOperations(config, deps = productionMediaOperationsDeps) {
 	const baseUrl = `${config.dashboardUrl}/api/sdk/${config.siteId}`;
 	const uploadTimeout = config.timeout ?? 10 * 60 * 1e3;
-	const http = createHttpClient(config);
+	const http = deps.createHttpClient(config);
 	return {
+		async list(options = {}) {
+			const params = {};
+			if (options.search !== undefined) params.search = options.search;
+			if (options.limit !== undefined) params.limit = String(options.limit);
+			if (options.offset !== undefined) params.offset = String(options.offset);
+			return http.get("/media", params);
+		},
+		async download(identifier, maxBytes) {
+			const path$2 = `/media/${encodeURIComponent(identifier)}/download`;
+			const transfer = await http.get(path$2);
+			const requestInfo = buildRequestInfo({
+				method: "GET",
+				path: path$2,
+				url: `${baseUrl}${path$2}`,
+				baseUrl,
+				dashboardUrl: config.dashboardUrl,
+				siteId: config.siteId
+			});
+			const response = await getMediaFile(transfer.transferUrl, uploadTimeout, requestInfo, deps.fetch);
+			return {
+				data: await readBoundedResponseBody(response, maxBytes),
+				asset: transfer.asset
+			};
+		},
+		async previewDelete(identifier) {
+			return http.post(`/media/${encodeURIComponent(identifier)}/delete-preview`);
+		},
+		async delete(identifier) {
+			return http.delete(`/media/${encodeURIComponent(identifier)}`);
+		},
 		async upload(file) {
-			return uploadMediaFile(config, http, baseUrl, uploadTimeout, file);
+			return uploadMediaFile(config, http, baseUrl, uploadTimeout, file, deps.fetch);
 		},
 		async exists(storagePath) {
 			const result = await http.post("/media/exists", { storagePath });
@@ -26174,7 +27298,48 @@ function createMediaOperations(config) {
 		}
 	};
 }
-async function uploadMediaFile(config, http, baseUrl, uploadTimeout, file) {
+async function readBoundedResponseBody(response, maxBytes) {
+	const declaredLength = response.headers.get("content-length");
+	if (declaredLength !== null && Number(declaredLength) > maxBytes) {
+		throw new ManagementApiError(`Download exceeds the ${maxBytes}-byte limit`, "sdk:download-too-large");
+	}
+	if (!response.body) return Buffer.alloc(0);
+	const chunks = [];
+	let totalBytes = 0;
+	const reader = response.body.getReader();
+	try {
+		for (;;) {
+			const chunk = await reader.read();
+			if (chunk.done) break;
+			totalBytes += chunk.value.byteLength;
+			if (totalBytes > maxBytes) {
+				await reader.cancel();
+				throw new ManagementApiError(`Download exceeds the ${maxBytes}-byte limit`, "sdk:download-too-large");
+			}
+			chunks.push(chunk.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)), totalBytes);
+}
+async function getMediaFile(transferUrl, timeout, requestInfo, fetchImpl) {
+	try {
+		const response = await fetchImpl(transferUrl, {
+			method: "GET",
+			signal: AbortSignal.timeout(timeout)
+		});
+		if (!response.ok) {
+			throw new ManagementApiError(`Download failed with status ${response.status}`, "sdk:http-error", undefined, response.status, requestInfo);
+		}
+		return response;
+	} catch (error) {
+		if (error instanceof ManagementApiError) throw error;
+		const timedOut = error instanceof Error && error.name === "TimeoutError";
+		throw new ManagementApiError(timedOut ? `Download timed out after ${timeout}ms` : error instanceof Error ? error.message : "Network request failed", timedOut ? "sdk:timeout" : "sdk:network-error", undefined, undefined, requestInfo);
+	}
+}
+async function uploadMediaFile(config, http, baseUrl, uploadTimeout, file, fetchImpl) {
 	const filename = file.filename || "upload";
 	const mimeType = file.contentType || "application/octet-stream";
 	const { signedUrl, storagePath, bucket } = await http.post("/media/upload-url", {
@@ -26192,7 +27357,7 @@ async function uploadMediaFile(config, http, baseUrl, uploadTimeout, file) {
 		dashboardUrl: config.dashboardUrl,
 		siteId: config.siteId
 	});
-	const response = await putMediaFile(signedUrl, file.data, mimeType, uploadTimeout, requestInfo);
+	const response = await putMediaFile(signedUrl, file.data, mimeType, uploadTimeout, requestInfo, fetchImpl);
 	if (!response.ok && response.status !== 409) {
 		throw new ManagementApiError(`Upload failed with status ${response.status}`, "sdk:http-error", undefined, response.status, requestInfo);
 	}
@@ -26206,9 +27371,9 @@ async function uploadMediaFile(config, http, baseUrl, uploadTimeout, file) {
 		identifier: file.identifier
 	});
 }
-async function putMediaFile(signedUrl, data, mimeType, timeout, requestInfo) {
+async function putMediaFile(signedUrl, data, mimeType, timeout, requestInfo, fetchImpl) {
 	try {
-		return await fetch(signedUrl, {
+		return await fetchImpl(signedUrl, {
 			method: "PUT",
 			headers: { "Content-Type": mimeType },
 			body: new Uint8Array(data),
@@ -26951,8 +28116,8 @@ async function withRiverbankEnv(target, run) {
 	}
 	const previous = envScopeQueue;
 	let release;
-	envScopeQueue = new Promise((resolve$1) => {
-		release = resolve$1;
+	envScopeQueue = new Promise((resolve$2) => {
+		release = resolve$2;
 	});
 	await previous;
 	const previousEnv = process.env.RIVERBANK_ENV;
@@ -27134,7 +28299,7 @@ function shouldConfirm(plan, prepared) {
 	return readyTargets(prepared).length > 0 && !hasPreparationBarrierFailure(plan, prepared);
 }
 function hasPreparationBarrierFailure(plan, prepared) {
-	return plan.targets.length > 1 && plan.policy.confirmation === "command" && prepared.some((entry) => entry.kind === "failed");
+	return plan.targets.length > 1 && (plan.policy.confirmation === "command" || plan.policy.preparationBarrier === "all-target") && prepared.some((entry) => entry.kind === "failed");
 }
 async function confirmPrepared(plan, prepared, deps) {
 	if (!shouldConfirm(plan, prepared)) return true;
@@ -27442,7 +28607,7 @@ function formatDateShort(isoDate) {
 */
 async function parseJsonData(options) {
 	if (options.file) {
-		const filePath = path.resolve(options.file);
+		const filePath = path$1.resolve(options.file);
 		const content = await fs.readFile(filePath, "utf-8");
 		return JSON.parse(content);
 	}
@@ -27496,12 +28661,12 @@ async function confirmAction(message, options, isRemote) {
 		input: process.stdin,
 		output: process.stderr
 	});
-	return new Promise((resolve$1) => {
+	return new Promise((resolve$2) => {
 		let settled = false;
 		const finish = (confirmed) => {
 			if (settled) return;
 			settled = true;
-			resolve$1(confirmed);
+			resolve$2(confirmed);
 		};
 		rl.once("close", () => finish(false));
 		rl.question(`${message} (y/N): `, (answer) => {
@@ -30624,19 +31789,19 @@ var require_react_development = /* @__PURE__ */ __commonJSMin(((exports, module)
 			prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
 			actScopeDepth = prevActScopeDepth;
 		}
-		function recursivelyFlushAsyncActWork(returnValue, resolve$1, reject) {
+		function recursivelyFlushAsyncActWork(returnValue, resolve$2, reject) {
 			var queue = ReactSharedInternals$1.actQueue;
 			if (null !== queue) if (0 !== queue.length) try {
 				flushActQueue(queue);
 				enqueueTask(function() {
-					return recursivelyFlushAsyncActWork(returnValue, resolve$1, reject);
+					return recursivelyFlushAsyncActWork(returnValue, resolve$2, reject);
 				});
 				return;
 			} catch (error) {
 				ReactSharedInternals$1.thrownErrors.push(error);
 			}
 			else ReactSharedInternals$1.actQueue = null;
-			0 < ReactSharedInternals$1.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals$1.thrownErrors), ReactSharedInternals$1.thrownErrors.length = 0, reject(queue)) : resolve$1(returnValue);
+			0 < ReactSharedInternals$1.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals$1.thrownErrors), ReactSharedInternals$1.thrownErrors.length = 0, reject(queue)) : resolve$2(returnValue);
 		}
 		function flushActQueue(queue) {
 			if (!isFlushing) {
@@ -30797,14 +31962,14 @@ var require_react_development = /* @__PURE__ */ __commonJSMin(((exports, module)
 				queueSeveralMicrotasks(function() {
 					didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
 				});
-				return { then: function(resolve$1, reject) {
+				return { then: function(resolve$2, reject) {
 					didAwaitActCall = !0;
 					thenable.then(function(returnValue) {
 						popActScope(prevActQueue, prevActScopeDepth);
 						if (0 === prevActScopeDepth) {
 							try {
 								flushActQueue(queue), enqueueTask(function() {
-									return recursivelyFlushAsyncActWork(returnValue, resolve$1, reject);
+									return recursivelyFlushAsyncActWork(returnValue, resolve$2, reject);
 								});
 							} catch (error$0) {
 								ReactSharedInternals$1.thrownErrors.push(error$0);
@@ -30814,7 +31979,7 @@ var require_react_development = /* @__PURE__ */ __commonJSMin(((exports, module)
 								ReactSharedInternals$1.thrownErrors.length = 0;
 								reject(_thrownError);
 							}
-						} else resolve$1(returnValue);
+						} else resolve$2(returnValue);
 					}, function(error) {
 						popActScope(prevActQueue, prevActScopeDepth);
 						0 < ReactSharedInternals$1.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals$1.thrownErrors), ReactSharedInternals$1.thrownErrors.length = 0, reject(error)) : reject(error);
@@ -30827,11 +31992,11 @@ var require_react_development = /* @__PURE__ */ __commonJSMin(((exports, module)
 				didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
 			}), ReactSharedInternals$1.actQueue = null);
 			if (0 < ReactSharedInternals$1.thrownErrors.length) throw callback = aggregateErrors(ReactSharedInternals$1.thrownErrors), ReactSharedInternals$1.thrownErrors.length = 0, callback;
-			return { then: function(resolve$1, reject) {
+			return { then: function(resolve$2, reject) {
 				didAwaitActCall = !0;
 				0 === prevActScopeDepth ? (ReactSharedInternals$1.actQueue = queue, enqueueTask(function() {
-					return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve$1, reject);
-				})) : resolve$1(returnValue$jscomp$0);
+					return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve$2, reject);
+				})) : resolve$2(returnValue$jscomp$0);
 			} };
 		};
 		exports.cache = function(fn) {
@@ -33777,13 +34942,13 @@ function optionalRef(ref, field) {
 		field
 	}] : [];
 }
-function collectVenueRefsFromIntervals(intervals, path$1) {
-	return intervals.flatMap((interval, index) => optionalRef(interval.venueRef, `${path$1}[${index}].venueRef`));
+function collectVenueRefsFromIntervals(intervals, path$2) {
+	return intervals.flatMap((interval, index) => optionalRef(interval.venueRef, `${path$2}[${index}].venueRef`));
 }
-function collectNavigationRefs(items, path$1) {
+function collectNavigationRefs(items, path$2) {
 	return items.flatMap((item, index) => {
 		if (!isRecord$5(item)) return [];
-		const itemPath = `${path$1}[${index}]`;
+		const itemPath = `${path$2}[${index}]`;
 		const refs = [];
 		if (typeof item.pageRef === "string") {
 			refs.push({
@@ -33803,26 +34968,26 @@ function collectNavigationRefs(items, path$1) {
 		return refs;
 	});
 }
-function collectBlockRefs(blocks, path$1) {
+function collectBlockRefs(blocks, path$2) {
 	return blocks.flatMap((block, index) => {
 		if (!isRecord$5(block)) return [];
-		const blockPath = `${path$1}[${index}]`;
+		const blockPath = `${path$2}[${index}]`;
 		return [...collectNestedRefs(block.props, `${blockPath}.props`), ...collectNestedRefs(block.children, `${blockPath}.children`)];
 	});
 }
-function collectNestedRefs(value, path$1) {
+function collectNestedRefs(value, path$2) {
 	if (typeof value === "string") {
 		const parsed = parseResourceRef(value);
 		return parsed.ok ? [{
 			ref: value,
-			field: path$1
+			field: path$2
 		}] : [];
 	}
 	if (Array.isArray(value)) {
-		return value.flatMap((item, index) => collectNestedRefs(item, `${path$1}[${index}]`));
+		return value.flatMap((item, index) => collectNestedRefs(item, `${path$2}[${index}]`));
 	}
 	if (!isRecord$5(value)) return [];
-	return Object.entries(value).flatMap(([key, child]) => collectNestedRefs(child, `${path$1}.${key}`));
+	return Object.entries(value).flatMap(([key, child]) => collectNestedRefs(child, `${path$2}.${key}`));
 }
 
 //#endregion
@@ -34088,8 +35253,8 @@ function invalidPayloadError(input, issue) {
 		message: `${field}: ${issue.message}`
 	};
 }
-function commandIndexForIssuePath(path$1) {
-	return path$1[0] === "commands" && typeof path$1[1] === "number" ? path$1[1] : -1;
+function commandIndexForIssuePath(path$2) {
+	return path$2[0] === "commands" && typeof path$2[1] === "number" ? path$2[1] : -1;
 }
 function commandTypeForIssue(input, commandIndex) {
 	if (!isRecord$5(input) || !isUnknownArray(input.commands)) return null;
@@ -34099,9 +35264,9 @@ function commandTypeForIssue(input, commandIndex) {
 function isUnknownArray(value) {
 	return Array.isArray(value);
 }
-function formatIssuePath(path$1) {
-	if (path$1.length === 0) return "<root>";
-	return path$1.reduce((formatted, segment) => {
+function formatIssuePath(path$2) {
+	if (path$2.length === 0) return "<root>";
+	return path$2.reduce((formatted, segment) => {
 		if (typeof segment === "number") return `${formatted}[${segment}]`;
 		if (formatted.length === 0) return String(segment);
 		return `${formatted}.${String(segment)}`;
@@ -34834,6 +35999,8 @@ const FILE_SIZE_LIMITS = {
 	instagramZip: unsafeAsPositiveByteCount(100 * 1024 * 1024),
 	bookingEvidence: unsafeAsPositiveByteCount(25 * 1024 * 1024)
 };
+/** Shared admission ceiling for SDK-management media uploads before intent-specific finalization. */
+const MAX_MANAGEMENT_MEDIA_UPLOAD_BYTES = unsafeAsPositiveByteCount(250 * 1024 * 1024);
 const DEFAULT_PRIVATE_FILE_SIGNED_URL_EXPIRY_SECONDS = unsafeAsPositiveSeconds(5 * 60);
 const MAX_SAFE_DOWNLOAD_FILENAME_LENGTH = 180;
 function asPositiveByteCount(value) {
@@ -35097,6 +36264,16 @@ function classifyKnownMimeType(mimeType) {
 		default: return err("unsupported-mime-type");
 	}
 }
+function managementMediaLibraryUploadLimitForMimeType(mimeType) {
+	const kind = classifyKnownMimeType(mimeType);
+	if (!kind.ok) return kind;
+	const renderUse = kind.value.tag;
+	if (renderUse !== "image" && renderUse !== "video" && renderUse !== "audio") {
+		return err("unsupported-mime-type");
+	}
+	const libraryLimit = mediaLibraryMaxBytes([renderUse]);
+	return ok(unsafeAsPositiveByteCount(Math.min(libraryLimit, MAX_MANAGEMENT_MEDIA_UPLOAD_BYTES)));
+}
 function isMimeTypeAllowedForPolicy(mimeType, policy) {
 	const kindResult = classifyKnownMimeType(mimeType);
 	return kindResult.ok && isFileKindAllowed(kindResult.value, policy);
@@ -35664,9 +36841,9 @@ function buildDurableFileStoragePath(input) {
 		input.fileAssetId,
 		input.safeDownloadFilename
 	];
-	const path$1 = joinStoragePathSegments(segments);
-	if (!path$1.ok) return path$1;
-	return ok(unsafeAsSiteScopedStoragePath(path$1.value));
+	const path$2 = joinStoragePathSegments(segments);
+	if (!path$2.ok) return path$2;
+	return ok(unsafeAsSiteScopedStoragePath(path$2.value));
 }
 function parseStoragePath(value) {
 	return joinStoragePathSegments(value.split("/"));
@@ -37091,10 +38268,10 @@ function emptyStatePatch(patch) {
 		rejection_reason: patch.rejection_reason ?? null
 	};
 }
-function traverse(items, parse) {
+function traverse(items, parse$1) {
 	const values = [];
 	for (const item of items) {
-		const parsed = parse(item);
+		const parsed = parse$1(item);
 		if (!parsed.ok) return parsed;
 		values.push(parsed.value);
 	}
@@ -37775,18 +38952,18 @@ function resolveFileDownload(input) {
 			assetKind: input.asset.kind
 		});
 	}
-	const access = authorizeFileAccess(input.actor, input.asset.accessPolicy);
-	if (!access.ok) {
+	const access$1 = authorizeFileAccess(input.actor, input.asset.accessPolicy);
+	if (!access$1.ok) {
 		return err({
 			tag: "access-denied",
-			reason: access.error
+			reason: access$1.error
 		});
 	}
 	return ok(fileAccessGrantToDownloadPlan({
 		asset: input.asset,
 		requestedUse: input.requestedUse,
 		disposition: input.disposition ?? defaultDispositionForFileUse(input.requestedUse),
-		grant: access.value
+		grant: access$1.value
 	}));
 }
 function fileAccessGrantToDownloadPlan(input) {
@@ -38317,9 +39494,9 @@ const EXTENSIONS_BY_MIME_TYPE = {
 };
 function fileExtension(filename) {
 	const pathSegments = filename.replace(/\\/g, "/").split("/");
-	const basename = pathSegments[pathSegments.length - 1] ?? filename;
-	const dotIndex = basename.lastIndexOf(".");
-	return dotIndex <= 0 ? "" : basename.slice(dotIndex).toLowerCase();
+	const basename$1 = pathSegments[pathSegments.length - 1] ?? filename;
+	const dotIndex = basename$1.lastIndexOf(".");
+	return dotIndex <= 0 ? "" : basename$1.slice(dotIndex).toLowerCase();
 }
 function getMimeType(filename) {
 	return MIME_TYPES_BY_EXTENSION[fileExtension(filename)] ?? "application/octet-stream";
@@ -38867,20 +40044,20 @@ function formatMediaUsageStage(stage) {
 function mediaUsageLocationLabel(location$1) {
 	switch (location$1.kind) {
 		case "pageBlock": {
-			const path$1 = location$1.pageDraftPath ?? location$1.pagePublishedPath ?? null;
+			const path$2 = location$1.pageDraftPath ?? location$1.pagePublishedPath ?? null;
 			const title = location$1.pageTitle ?? "Untitled page";
-			const where = path$1 ? `${title} (${path$1})` : title;
+			const where = path$2 ? `${title} (${path$2})` : title;
 			return `${where} — ${formatMediaUsageStage(location$1.stage)} — Block: ${location$1.blockKind}`;
 		}
 		case "entrySlotBlock": {
-			const path$1 = location$1.routeDraftPath ?? location$1.routePublishedPath ?? null;
-			const where = path$1 ? `${location$1.entryTitle} (${path$1})` : location$1.entryTitle;
+			const path$2 = location$1.routeDraftPath ?? location$1.routePublishedPath ?? null;
+			const where = path$2 ? `${location$1.entryTitle} (${path$2})` : location$1.entryTitle;
 			return `${where} — Page Content: ${location$1.slotKey} — ${formatMediaUsageStage(location$1.stage)} — Block: ${location$1.blockKind}`;
 		}
 		case "surfaceSlotBlock": return `Page surface ${location$1.pageSurfaceId} — Page Content: ${location$1.slotKey} — ${formatMediaUsageStage(location$1.stage)} — Block: ${location$1.blockKind}`;
 		case "contentEntry": {
-			const path$1 = location$1.routeDraftPath ?? location$1.routePublishedPath ?? null;
-			const where = path$1 ? `${location$1.entryTitle} (${path$1})` : location$1.entryTitle;
+			const path$2 = location$1.routeDraftPath ?? location$1.routePublishedPath ?? null;
+			const where = path$2 ? `${location$1.entryTitle} (${path$2})` : location$1.entryTitle;
 			return `${where} — ${formatMediaUsageStage(location$1.stage)}`;
 		}
 		case "productFileDownload": return `${location$1.productTitle} — Product download`;
@@ -38910,10 +40087,17 @@ function hasMediaUsage(response) {
 	return response.items.some((item) => item.usedCount > 0);
 }
 function planBulkDeleteCompletionToast(result) {
+	const hasWarnings = (result.warnings?.length ?? 0) > 0;
 	if (result.failed > 0) {
 		return {
 			kind: "error",
-			message: `Deleted ${result.deleted}. Failed to delete ${result.failed}.`
+			message: hasWarnings ? `Deleted ${result.deleted}. Failed to delete ${result.failed}. Some cleanup could not be completed.` : `Deleted ${result.deleted}. Failed to delete ${result.failed}.`
+		};
+	}
+	if (hasWarnings) {
+		return {
+			kind: "warning",
+			message: result.deleted === 1 ? "Deleted 1 media item, but some cleanup could not be completed." : `Deleted ${result.deleted} media items, but some cleanup could not be completed.`
 		};
 	}
 	return {
@@ -39178,7 +40362,7 @@ const ORDER = [
 ];
 const getImageUrl = (asset, params = {}, basePath = DEFAULT_BASE_PATH) => {
 	const trimmedBase = basePath.endsWith("/") ? basePath.slice(0, Math.max(basePath.length - 1, 0)) : basePath;
-	const path$1 = `${trimmedBase}/${encodeURIComponent(asset.id)}`;
+	const path$2 = `${trimmedBase}/${encodeURIComponent(asset.id)}`;
 	const searchParams = new URLSearchParams();
 	if (params.w !== undefined) searchParams.set("w", formatNumber(params.w));
 	if (params.h !== undefined) searchParams.set("h", formatNumber(params.h));
@@ -39197,7 +40381,7 @@ const getImageUrl = (asset, params = {}, basePath = DEFAULT_BASE_PATH) => {
 		if (value !== null) sorted.set(key, value);
 	});
 	const query = sorted.toString();
-	return query ? `${path$1}?${query}` : path$1;
+	return query ? `${path$2}?${query}` : path$2;
 };
 
 //#endregion
@@ -39967,8 +41151,8 @@ function mediaIdentifierOrFallback(current, fallback) {
 function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function formatContentFieldPath(path$1) {
-	return path$1.map((segment, index) => typeof segment === "number" ? `[${segment}]` : index === 0 ? segment : `.${segment}`).join("");
+function formatContentFieldPath(path$2) {
+	return path$2.map((segment, index) => typeof segment === "number" ? `[${segment}]` : index === 0 ? segment : `.${segment}`).join("");
 }
 function summarizeContentMediaValue(value) {
 	if (typeof value === "string") {
@@ -39981,7 +41165,7 @@ function summarizeContentMediaValue(value) {
 	if (isRecord$4(value)) return `object(${Object.keys(value).sort().join(",")})`;
 	return typeof value;
 }
-function auditMediaValue(context, path$1, allowedMediaTypes$1, value) {
+function auditMediaValue(context, path$2, allowedMediaTypes$1, value) {
 	const expectedMediaType = allowedMediaTypes$1[0];
 	if (value === undefined || value === null) return [];
 	if (typeof value === "string") {
@@ -39990,7 +41174,7 @@ function auditMediaValue(context, path$1, allowedMediaTypes$1, value) {
 			return [{
 				tag: "blank-string",
 				context,
-				path: path$1,
+				path: path$2,
 				valueSummary: summarizeContentMediaValue(value),
 				expectedMediaType
 			}];
@@ -39998,7 +41182,7 @@ function auditMediaValue(context, path$1, allowedMediaTypes$1, value) {
 		return [{
 			tag: "legacy-string",
 			context,
-			path: path$1,
+			path: path$2,
 			valueSummary: summarizeContentMediaValue(value),
 			originalValue: value,
 			expectedMediaType,
@@ -40014,7 +41198,7 @@ function auditMediaValue(context, path$1, allowedMediaTypes$1, value) {
 	return [{
 		tag: "malformed-object",
 		context,
-		path: path$1,
+		path: path$2,
 		valueSummary: summarizeContentMediaValue(value),
 		expectedMediaType
 	}];
@@ -40417,8 +41601,8 @@ function mediaTypeFromAsset(row) {
 }
 function legacyStorageValues(siteId, storagePath) {
 	const sitePrefix = `sites/${siteId}/`;
-	const relative = storagePath.startsWith(sitePrefix) ? storagePath.slice(sitePrefix.length) : storagePath;
-	return [...new Set([storagePath, `/${relative}`])];
+	const relative$1 = storagePath.startsWith(sitePrefix) ? storagePath.slice(sitePrefix.length) : storagePath;
+	return [...new Set([storagePath, `/${relative$1}`])];
 }
 function assetCandidates(rows) {
 	return rows.flatMap((row) => {
@@ -40806,10 +41990,10 @@ var BrowserImage = class extends ImageBase {
 			return Promise.reject(new Error(`Cannot load buffer as an image in browser`));
 		}
 		this.image = img;
-		return new Promise((resolve$1, reject) => {
+		return new Promise((resolve$2, reject) => {
 			const onImageLoad = () => {
 				this._initCanvas();
-				resolve$1(this);
+				resolve$2(this);
 			};
 			if (img.complete) {
 				onImageLoad();
@@ -42395,7 +43579,7 @@ const isMediaValue = (value) => isRecordValue(value) && !("attrs" in value) && t
 //#endregion
 //#region src/content/media-manifest.ts
 const MANIFEST_VERSION = 2;
-const getManifestPath = (contentDir) => path.join(contentDir, "media", ".manifest.json");
+const getManifestPath = (contentDir) => path$1.join(contentDir, "media", ".manifest.json");
 const ensureDir = async (dirPath) => {
 	try {
 		await fs.mkdir(dirPath, { recursive: true });
@@ -42487,7 +43671,7 @@ async function readMediaManifest(contentDir) {
 	return createEmptyMediaManifest();
 }
 async function writeMediaManifest(contentDir, manifest) {
-	const mediaDir = path.join(contentDir, "media");
+	const mediaDir = path$1.join(contentDir, "media");
 	await ensureDir(mediaDir);
 	const updatedManifest = {
 		...manifest,
@@ -42623,7 +43807,7 @@ const DEFAULT_RETRY_CONFIG = {
 * Sleep for a given number of milliseconds.
 */
 function sleep(ms) {
-	return new Promise((resolve$1) => setTimeout(resolve$1, ms));
+	return new Promise((resolve$2) => setTimeout(resolve$2, ms));
 }
 /**
 * Calculate exponential backoff delay with jitter.
@@ -42732,8 +43916,8 @@ const TRANSFORMABLE_EXTENSIONS = [
 * Check if a file path is an image that can be transformed by Supabase.
 * @param path - The file path or storage path
 */
-function isTransformableImage(path$1) {
-	const ext = path$1.split(".").pop()?.toLowerCase();
+function isTransformableImage(path$2) {
+	const ext = path$2.split(".").pop()?.toLowerCase();
 	return TRANSFORMABLE_EXTENSIONS.includes(ext ?? "");
 }
 /**
@@ -43044,7 +44228,7 @@ function collectRichTextImageAttrs(value, out = [], location$1 = "") {
 //#endregion
 //#region src/media/pull-manifest.ts
 const buildLocalFilename = (identifier, asset) => {
-	const extensionFromFilename = path.extname(asset.filename ?? "");
+	const extensionFromFilename = path$1.extname(asset.filename ?? "");
 	const extension = extensionFromFilename || getExtensionForMimeType(asset.mimeType) || "";
 	return extension ? `${identifier}${extension}` : identifier;
 };
@@ -43366,6 +44550,165 @@ function sha256(buffer) {
 	return createHash("sha256").update(buffer).digest("hex");
 }
 
+//#endregion
+//#region src/files/stable-binary-file.ts
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+function observationsMatch(left, right) {
+	return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+function admitStableBinaryRead(stats, maxBytes) {
+	if (!stats.isFile()) return err({ tag: "not_a_regular_file" });
+	return stats.size > maxBytes ? err({
+		tag: "file_too_large",
+		maxBytes,
+		actualBytes: stats.size
+	}) : ok(undefined);
+}
+function mapStableBinaryReadFailure(error) {
+	if (!isNodeError(error)) return { tag: "read_failed" };
+	if (error.code === "ENOENT") return { tag: "file_not_found" };
+	return error.code === "ELOOP" || error.code === "EISDIR" ? { tag: "not_a_regular_file" } : { tag: "read_failed" };
+}
+async function readObservedByteLength(handle, byteLength) {
+	const data = Buffer.allocUnsafe(byteLength);
+	let offset = 0;
+	while (offset < byteLength) {
+		const read = await handle.read(data, offset, byteLength - offset, offset);
+		if (read.bytesRead === 0) return null;
+		offset += read.bytesRead;
+	}
+	const growthProbe = Buffer.allocUnsafe(1);
+	const extra = await handle.read(growthProbe, 0, 1, byteLength);
+	return extra.bytesRead === 0 ? data : null;
+}
+async function readStableBinaryFile(filePath, maxBytes) {
+	let handle;
+	try {
+		const noFollow = constants.O_NOFOLLOW ?? 0;
+		handle = await open(filePath, constants.O_RDONLY | noFollow);
+		const before = await handle.stat();
+		const admission = admitStableBinaryRead(before, maxBytes);
+		if (!admission.ok) return admission;
+		const data = await readObservedByteLength(handle, before.size);
+		const after = await handle.stat();
+		if (data === null || !observationsMatch(before, after)) {
+			return err({ tag: "file_changed_during_read" });
+		}
+		return ok(data);
+	} catch (error) {
+		return err(mapStableBinaryReadFailure(error));
+	} finally {
+		await handle?.close().catch(() => undefined);
+	}
+}
+async function inspectDestination(filePath, overwrite) {
+	try {
+		const stats = await lstat(filePath);
+		if (overwrite === "refuse") return err({ tag: "destination_exists" });
+		return stats.isFile() ? ok(undefined) : err({ tag: "unsafe_destination" });
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return ok(undefined);
+		return err({ tag: "write_failed" });
+	}
+}
+/**
+* Admit an output path before a remote operation while preserving the atomic
+* writer's second check at finalization time to close the race window.
+*/
+async function admitBinaryWriteDestination(filePath, overwrite) {
+	const destination = await inspectDestination(filePath, overwrite);
+	if (!destination.ok) return destination;
+	try {
+		const parent = dirname$1(filePath);
+		const parentStats = await lstat(parent);
+		if (!parentStats.isDirectory()) return err({ tag: "unsafe_destination" });
+		await access(parent, constants.W_OK);
+		return ok(undefined);
+	} catch {
+		return err({ tag: "write_failed" });
+	}
+}
+async function syncDirectory(directory) {
+	if (process.platform === "win32") return true;
+	let handle;
+	try {
+		handle = await open(directory, "r");
+		await handle.sync();
+		return true;
+	} catch {
+		return false;
+	} finally {
+		await handle?.close().catch(() => undefined);
+	}
+}
+function mapAtomicBinaryWriteFailure(error) {
+	return isNodeError(error) && (error.code === "ELOOP" || error.code === "EISDIR" || error.code === "ENOTDIR") ? { tag: "unsafe_destination" } : { tag: "write_failed" };
+}
+async function writeTemporaryBinaryFile(temporaryPath, data, mode) {
+	let handle;
+	try {
+		handle = await open(temporaryPath, "wx", mode);
+		await handle.writeFile(data);
+		await handle.sync();
+		await handle.close();
+		handle = undefined;
+		await chmod(temporaryPath, mode);
+	} finally {
+		await handle?.close().catch(() => undefined);
+	}
+}
+async function finalizeTemporaryBinaryFile(temporaryPath, filePath, overwrite) {
+	if (overwrite === "allow") {
+		await rename(temporaryPath, filePath);
+		return ok([]);
+	}
+	try {
+		await link(temporaryPath, filePath);
+	} catch (error) {
+		return isNodeError(error) && error.code === "EEXIST" ? err({ tag: "destination_exists" }) : err(mapAtomicBinaryWriteFailure(error));
+	}
+	try {
+		await unlink$1(temporaryPath);
+		return ok([]);
+	} catch {
+		return ok([{
+			tag: "temporary_cleanup_failed",
+			temporaryPath
+		}]);
+	}
+}
+function toAtomicBinaryWriteOutcome(warnings) {
+	const [first, ...rest] = warnings;
+	return first === undefined ? { tag: "written" } : {
+		tag: "written_with_warnings",
+		warnings: [first, ...rest]
+	};
+}
+async function writeBinaryFileAtomic(filePath, data, options) {
+	const parent = dirname$1(filePath);
+	const mode = options.mode ?? 384;
+	const suffix = options.randomSuffix ?? (() => `${process.pid}-${Date.now()}-${randomUUID()}`);
+	let temporaryPath;
+	try {
+		if (options.ensureParent === true) await mkdir(parent, { recursive: true });
+		const admitted = await inspectDestination(filePath, options.overwrite);
+		if (!admitted.ok) return admitted;
+		temporaryPath = join(parent, `.${basename(filePath)}.${suffix()}.tmp`);
+		await writeTemporaryBinaryFile(temporaryPath, data, mode);
+		const finalized = await finalizeTemporaryBinaryFile(temporaryPath, filePath, options.overwrite);
+		if (!finalized.ok) return finalized;
+		temporaryPath = undefined;
+		const warnings = await syncDirectory(parent) ? finalized.value : [...finalized.value, { tag: "directory_sync_failed" }];
+		return ok(toAtomicBinaryWriteOutcome(warnings));
+	} catch (error) {
+		return err(mapAtomicBinaryWriteFailure(error));
+	} finally {
+		if (temporaryPath) await unlink$1(temporaryPath).catch(() => undefined);
+	}
+}
+
 //#endregion
 //#region src/media/local-media.ts
 const MEDIA_DIR_NAME = "media";
@@ -43387,10 +44730,10 @@ const listMediaDirFiles = async (mediaDir) => {
 	}
 };
 const findMatchingFilename = async (contentDir, identifier, manifest) => {
-	const mediaDir = path.join(contentDir, MEDIA_DIR_NAME);
+	const mediaDir = path$1.join(contentDir, MEDIA_DIR_NAME);
 	const manifestEntry = manifest.assets[identifier];
 	if (manifestEntry?.filename) {
-		const candidatePath = path.join(mediaDir, manifestEntry.filename);
+		const candidatePath = path$1.join(mediaDir, manifestEntry.filename);
 		if (await fileExists(candidatePath)) {
 			return manifestEntry.filename;
 		}
@@ -43398,7 +44741,7 @@ const findMatchingFilename = async (contentDir, identifier, manifest) => {
 	const files = await listMediaDirFiles(mediaDir);
 	const matches = files.filter((name) => {
 		if (name.startsWith(".")) return false;
-		const parsed = path.parse(name);
+		const parsed = path$1.parse(name);
 		return parsed.name === identifier;
 	});
 	if (matches.length > 1) {
@@ -43409,9 +44752,13 @@ const findMatchingFilename = async (contentDir, identifier, manifest) => {
 async function loadLocalMediaFile(contentDir, identifier, manifest) {
 	const filename = await findMatchingFilename(contentDir, identifier, manifest);
 	if (!filename) return null;
-	const mediaDir = path.join(contentDir, MEDIA_DIR_NAME);
-	const filePath = path.join(mediaDir, filename);
-	const data = await fs.readFile(filePath);
+	const mediaDir = path$1.join(contentDir, MEDIA_DIR_NAME);
+	const filePath = path$1.join(mediaDir, filename);
+	const read = await readStableBinaryFile(filePath, MAX_MANAGEMENT_MEDIA_UPLOAD_BYTES);
+	if (!read.ok) {
+		throw new Error(`Failed to read media file ${filePath}: ${read.error.tag}`);
+	}
+	const data = read.value;
 	const checksum = sha256(data);
 	const mimeType = getMimeType(filename);
 	manifest.assets[identifier] = {
@@ -43430,15 +44777,31 @@ async function loadLocalMediaFile(contentDir, identifier, manifest) {
 	};
 }
 async function writeLocalMediaFile(contentDir, filename, data) {
-	const mediaDir = path.join(contentDir, MEDIA_DIR_NAME);
+	const mediaDir = path$1.join(contentDir, MEDIA_DIR_NAME);
 	await fs.mkdir(mediaDir, { recursive: true });
-	const filePath = path.join(mediaDir, filename);
-	await fs.writeFile(filePath, data);
-	return filePath;
+	const filePath = path$1.join(mediaDir, filename);
+	const written = await writeBinaryFileAtomic(filePath, data, {
+		overwrite: "allow",
+		mode: 420
+	});
+	if (!written.ok) {
+		throw new Error(`Failed to write media file ${filePath}: ${written.error.tag}`);
+	}
+	return written.value.tag === "written" ? {
+		kind: "written",
+		filePath
+	} : {
+		kind: "written_with_warnings",
+		filePath,
+		warnings: written.value.warnings
+	};
 }
-async function readLocalMediaChecksum(filePath) {
-	const data = await fs.readFile(filePath);
-	return sha256(data);
+async function readLocalMediaChecksum(filePath, maxBytes) {
+	const read = await readStableBinaryFile(filePath, maxBytes);
+	if (!read.ok) {
+		throw new Error(`Failed to read media file ${filePath}: ${read.error.tag}`);
+	}
+	return sha256(read.value);
 }
 async function localMediaFileExists(filePath) {
 	return fileExists(filePath);
@@ -43503,7 +44866,7 @@ const parseFilenameFromUrl = (src) => {
 	}
 };
 const ensureFilenameExtension = (filename, mimeType) => {
-	if (path.extname(filename)) return filename;
+	if (path$1.extname(filename)) return filename;
 	const ext = getExtensionForMimeType(mimeType);
 	return ext ? `${filename}${ext}` : filename;
 };
@@ -44680,7 +46043,7 @@ const removeStaleLocalFile = async (options) => {
 	if (options.dryRun || !options.previousFilename || options.previousFilename === options.filename) {
 		return;
 	}
-	const previousPath = path.join(options.contentDir, "media", options.previousFilename);
+	const previousPath = path$1.join(options.contentDir, "media", options.previousFilename);
 	if (await localMediaFileExists(previousPath)) {
 		await fs.unlink(previousPath).catch(() => {});
 	}
@@ -44711,7 +46074,8 @@ const applyDownloadDecision = async (decision, context) => {
 		context.warnings.push(`Failed to download media for "${decision.identifier}" from ${urlResult.value}.`);
 		return;
 	}
-	await writeLocalMediaFile(context.contentDir, decision.filename, downloaded.data);
+	const written = await writeLocalMediaFile(context.contentDir, decision.filename, downloaded.data);
+	context.warnings.push(...localMediaWriteWarningMessages(decision.identifier, written));
 	context.manifest.assets[decision.identifier] = {
 		checksum: sha256(downloaded.data),
 		filename: decision.filename,
@@ -44728,7 +46092,7 @@ const syncPullMediaDownload = async (planned, indexes, context) => {
 		return;
 	}
 	const filename = buildLocalFilename(identifier, asset);
-	const localFilePath = path.join(context.contentDir, "media", filename);
+	const localFilePath = path$1.join(context.contentDir, "media", filename);
 	const existingEntry = context.manifest.assets[identifier];
 	await removeStaleLocalFile({
 		contentDir: context.contentDir,
@@ -44766,10 +46130,16 @@ const syncPullMediaDownloads = async (options) => {
 	}
 	if (!options.dryRun) options.summary.pendingDownloads = 0;
 };
-const sha256FromFile = async (filePath) => {
-	const buffer = await fs.readFile(filePath);
-	return sha256(buffer);
-};
+const sha256FromFile = (filePath) => readLocalMediaChecksum(filePath, FILE_SIZE_LIMITS.rawVideoBeforeCompression);
+function localMediaWriteWarningMessages(identifier, outcome) {
+	if (outcome.kind === "written") return [];
+	return outcome.warnings.map((warning) => {
+		switch (warning.tag) {
+			case "temporary_cleanup_failed": return `Downloaded media for "${identifier}", but could not remove temporary file ${warning.temporaryPath}.`;
+			case "directory_sync_failed": return `Downloaded media for "${identifier}", but could not confirm the destination directory was synced.`;
+		}
+	});
+}
 
 //#endregion
 //#region src/media/pull-workflow.ts
@@ -45189,4 +46559,4 @@ Examples:
 }
 
 //#endregion
-export { pagePathForCommand as $, NAV_LINK_BORDER_RADIUS_MAP as $n, DEFAULT_SURFACE_TEXT_COLOR as $r, loadSdkEnvironment as $t, getDirectImageUrlForRelativePath as A, sdkConfiguredBookingVerticalConfigSchema as Ai, MQ_MD_DOWN as An, resolveContextualButtonRole as Ar, mapEntryForOutput as At, sortRecord as B, eventListTreatmentValues as Bn, textColorStyle as Br, executeEnvironmentPlan as Bt, deleteEnvSpecificKeys as C, internalLinkSchema as Ci, getHeaderPaintTargets as Cn, generateButtonCss as Cr, createListCommand$1 as Ct, isExplicitRectCrop as D, isResolvedInternalLinkEntityType as Di, BREAKPOINT_SM as Dn, contextualButtonSurfaceResetStyles as Dr, getOutputContext as Dt, normalizeWidthCandidates as E, isInternalResolvedLinkValue as Ei, BREAKPOINT_MD as En, resolvedButtonFocusDeclarations as Er, formatDateShort as Et, resolveVideoSelectionIntentForMediaField as F, pageDesignEditorBackgroundOverrideOwner as Fn, backgroundColorStyle as Fr, runWithInvocation as Ft, evaluateSiteCommandBatchExposure as G, offeringsPreviewCompositionTreatmentValues as Gn, generateInteractiveChildInheritanceCSS as Gr, withRiverbankEnv as Gt, createDryRunReport as H, featureCardCompositionTreatmentValues as Hn, generateDefaultButtonSystem as Hr, planEnvironmentExecution as Ht, asRecord as I, assertNever$5 as In, borderColorStyle as Ir, withCommandContext as It, blockIdentifierForCommand as J, visibleHeadingDecorationFamilyValues as Jn, themeButtonClassName as Jr, getEnvPrefix as Jt, evaluateSiteCommandExposure as K, testimonialsCompositionTreatmentValues as Kn, TokenResolver as Kr, formatError as Kt, parseRelativeStoragePath as L, defineBlockDesignCapability as Ln, cssVarValue as Lr, withConfirmation as Lt, getImageUrl as M, MQ_SM_UP as Mn, resolveOnColorForThemeToken as Mr, parseJsonData as Mt, isSiteScopedDirectImageStoragePath as N, MQ_TABLET_ONLY as Nn, resolveThemeColorReferenceValue as Nr, parsePaginationOptions as Nt, parseAspectRatioValue as O, linkSchema as Oi, BREAKPOINT_XL as On, contextualButtonSurfaceStyles as Or, getOutputOnlyContext as Ot, deriveVideoSlotPolicy as P, headerVariantValues as Pn, resolveTokenOrCssColorValue as Pr, resolveCommandPath as Pt, pageIdentifierForCommand as Q, parseCustomCssRules as Qn, generateShadowValue$1 as Qr, isRemoteConfigured as Qt, classifyKnownMimeType as R, defineFrameCapability as Rn, mergeStyles as Rr, withErrorHandling as Rt, walkAndCollectImageAttrs as S, externalLinkSchema$1 as Si, generateMobileOverlayBackdropFilterFix as Sn, AFFORDANCE_SUPPRESS_CLASS as Sr, createGetCommand as St, rotateNormalizedPoint as T, internalRouteOnlyLinkSchema as Ti, BREAKPOINT_LG as Tn, resolvedButtonColourDeclarations as Tr, currentInvocationEnvelope as Tt, parseAndPlanCommandBatchForTypes as U, headingDecorationColorTokenValues as Un, generateEffectsCSS as Ur, planEnvironmentWriteAuthorization as Ut, stableStringify as V, eyebrowTreatmentValues as Vn, resolveSurfaceForeground as Vr, parseEnvironmentSelection as Vt, mapEventCommandContent as W, introCompositionTreatmentValues as Wn, generateBaseInteractiveCSS as Wr, requireEnvironmentWriteAuthorization as Wt, entryIdentifierForCommand as X, getComponentShadowVar as Xn, compileButtonColourStates as Xr, getEnvironmentDebugInfo as Xt, blockOrderIdentifiersForCommand as Y, getComponentBorderWidthPx as Yn, parseThemeForPersistence as Yr, getEnvVarName as Yt, pageIdentifierForBlockCommand as Z, parseBlockCustomCssRules as Zn, formatButtonColourContractError as Zr, isLocalConfigured as Zt, hasOwnSettingsField as _, persistableMediaSchema as _i, sdkThemeWireSchema as _n, generateShadowValue as _r, refSlug as _t, syncLocalMediaForPull as a, onColorTokenName as ai, getCuratedSiteStyle as an, INPUT_FONT_SIZE_MAP as ar, createBlockRef as at, attachRenderableMediaAssetFields as b, customLinkSchema$1 as bi, boxBackgroundSchema as bn, normalizeCardRole as br, createClientForEnv as bt, sha256 as c, featuresFromHex as ci, getGradientPreset as cn, ACCORDION_OPEN_ACCENT_THICKNESS as cr, createContentEntryRef as ct, walkLocalContentMedia as d, buttonVariantIdSchema as di, backgroundAppearanceColorTokenNames as dn, ACCORDION_TRIGGER_LETTER_SPACING as dr, createFooterRef as dt, surfaceForegroundDeclarations as ei, createManagementClient as en, NAV_LINK_LETTER_SPACING_MAP as er, hasConfiguredBookingVertical as et, buildStorageUrl as f, unsafeAsOpaqueButtonColourToken as fi, backgroundAppearanceQuickColorTokenNames as fn, ICON_CONFIG as fr, createFormRef as ft, buildSettingsUpdateInput as g, mediaTypeDiscriminants as gi, sdkSettingsUpdateSchema as gn, generateCardCss as gr, createVenueRef as gt, SETTINGS_FILE_FIELDS as h, mediaSchema as hi, defineBlockDesignMetadata as hn, getDefaultCardVariants as hr, createSiteCommandSiteRef as ht, syncLocalMediaForPush as i, isOnColorBackgroundCandidateToken as ii, readHeaderNavFontSizePreference as in, FONT_WEIGHT_MAP as ir, generateCssVars as it, getDirectImageUrlForSiteScopedPath as j, __toESM as ji, MQ_SM_DOWN as jn, isCssColorLiteral as jr, parseJsonArray as jt, resolveMediaTransformForAspect as k, pageLinkSchema$1 as ki, MQ_LG_UP as kn, deriveButtonSurfaceContext as kr, handleCommandError as kt, normalizeMediaIdentifierInput as l, hexToRgb$1 as li, parseGradientPresetId as ln, ACCORDION_SPACING_MAP as lr, createEventCategoryRef as lt, extractMediaIdentifiers as m, mediaIdentifierSchema as mi, defaultThemeTokens as mn, generateCardCoreCss as mr, createPageRef as mt, createStyleCommand as n, surfaceForegroundValue as ni, ManagementApiError as nn, NAV_LINK_PADDING_X_MAP as nr, require_react as nt, applyLocalMediaPush as o, getTextColorForBackground as oi, gradientToCss as on, INPUT_SPACING_MAP as or, createBlocksRef as ot, downloadMedia as p, parseBlockColorToken as pi, parseBackgroundAppearanceColorToken as pn, ICON_SIZE_PX as pr, createNavigationRef as pt, getSiteCommandMetadata as q, tileTreatmentValues as qn, parseThemeButtonVariantId as qr, CliExit as qt, revalidateLocalMediaPushPlan as r, expandPalette as ri, mergeHeaderNavTypographyPreference as rn, NAV_LINK_TEXT_SIZE_MAP as rr, pickShadeTowardBackground as rt, prepareLocalMediaForPush as s, ORDINARY_TEXT_MIN_CONTRAST_RATIO as si, GRADIENT_PRESET_IDS as sn, LABEL_FONT_SIZE_MAP as sr, createCommandRef as st, buildStyleSelectionInitializeCommandFromOptions as t, surfaceForegroundStyle as ti, formatIgnoredDocumentSyncSectionWarning as tn, NAV_LINK_PADDING_MAP as tr, require_jsx_runtime as tt, normalizeMediaValueToIdentifierOnly as u, VARIANT_ROLES as ui, boundaryRuntimeMetricsForTransition as un, ACCORDION_TRIGGER_FONT_SCALE as ur, createEventSeriesRef as ut, writeMediaManifest as v, linkPayloadSchema as vi, themeSchema as vn, cardRoleSchema as vr, slugPart as vt, looksLikeUuid as w, internalResolvedLinkSchema as wi, renderHeaderPaintTargetRules as wn, RESOLVED_BUTTON_DISABLED_DECLARATIONS as wr, createOutputForCommand as wt, buildRenderableMediaAssetIndex as x, entryLinkSchema$1 as xi, generateHeaderScrollTreatmentStyles as xn, PUBLIC_BUTTON_ROLES as xr, createCommandContext as xt, isMediaValue as y, RESOLVED_INTERNAL_LINK_ENTITY_TYPES as yi, boxBackgroundOverlaySchema as yn, cardVariantRoleValues as yr, confirmAction as yt, venueManagementFields as z, defineNoBlockDesignCapability as zn, rgbColorValue as zr, withOutputOnlyErrorHandling as zt };
+export { mapEventCommandContent as $, headingDecorationColorTokenValues as $n, generateEffectsCSS as $r, requireEnvironmentWriteAuthorization as $t, isExplicitRectCrop as A, customLinkSchema$1 as Ai, boxBackgroundSchema as An, normalizeCardRole as Ar, createCommandContext as At, resolveVideoSelectionIntentForMediaField as B, sdkConfiguredBookingVerticalConfigSchema as Bi, MQ_MD_DOWN as Bn, resolveContextualButtonRole as Br, parseJsonArray as Bt, attachRenderableMediaAssetFields as C, parseBlockColorToken as Ci, parseBackgroundAppearanceColorToken as Cn, ICON_SIZE_PX as Cr, createPageRef as Ct, looksLikeUuid as D, persistableMediaSchema as Di, sdkThemeWireSchema as Dn, generateShadowValue as Dr, slugPart as Dt, deleteEnvSpecificKeys as E, mediaTypeDiscriminants as Ei, sdkSettingsUpdateSchema as En, generateCardCss as Er, refSlug as Et, getImageUrl as F, internalRouteOnlyLinkSchema as Fi, BREAKPOINT_LG as Fn, resolvedButtonColourDeclarations as Fr, formatDateShort as Ft, classifyKnownMimeType as G, pageDesignEditorBackgroundOverrideOwner as Gn, backgroundColorStyle as Gr, withCommandContext as Gt, asRecord as H, MQ_SM_UP as Hn, resolveOnColorForThemeToken as Hr, parsePaginationOptions as Ht, isSiteScopedDirectImageStoragePath as I, isInternalResolvedLinkValue as Ii, BREAKPOINT_MD as In, resolvedButtonFocusDeclarations as Ir, getOutputContext as It, venueManagementFields as J, defineFrameCapability as Jn, mergeStyles as Jr, withOutputOnlyErrorHandling as Jt, managementMediaLibraryUploadLimitForMimeType as K, assertNever$5 as Kn, borderColorStyle as Kr, withConfirmation as Kt, buildMediaIdentifierFromFilename as L, isResolvedInternalLinkEntityType as Li, BREAKPOINT_SM as Ln, contextualButtonSurfaceResetStyles as Lr, getOutputOnlyContext as Lt, resolveMediaTransformForAspect as M, externalLinkSchema$1 as Mi, generateMobileOverlayBackdropFilterFix as Mn, AFFORDANCE_SUPPRESS_CLASS as Mr, createListCommand$1 as Mt, getDirectImageUrlForRelativePath as N, internalLinkSchema as Ni, getHeaderPaintTargets as Nn, generateButtonCss as Nr, createOutputForCommand as Nt, rotateNormalizedPoint as O, linkPayloadSchema as Oi, themeSchema as On, cardRoleSchema as Or, confirmAction as Ot, getDirectImageUrlForSiteScopedPath as P, internalResolvedLinkSchema as Pi, renderHeaderPaintTargetRules as Pn, RESOLVED_BUTTON_DISABLED_DECLARATIONS as Pr, currentInvocationEnvelope as Pt, parseAndPlanCommandBatchForTypes as Q, featureCardCompositionTreatmentValues as Qn, generateDefaultButtonSystem as Qr, planEnvironmentWriteAuthorization as Qt, parseMediaIdentifier as R, linkSchema as Ri, BREAKPOINT_XL as Rn, contextualButtonSurfaceStyles as Rr, handleCommandError as Rt, isMediaValue as S, unsafeAsOpaqueButtonColourToken as Si, backgroundAppearanceQuickColorTokenNames as Sn, ICON_CONFIG as Sr, createNavigationRef as St, walkAndCollectImageAttrs as T, mediaSchema as Ti, defineBlockDesignMetadata as Tn, getDefaultCardVariants as Tr, createVenueRef as Tt, parseRelativeStoragePath as U, MQ_TABLET_ONLY as Un, resolveThemeColorReferenceValue as Ur, resolveCommandPath as Ut, getMimeType as V, __toESM as Vi, MQ_SM_DOWN as Vn, isCssColorLiteral as Vr, parseJsonData as Vt, FILE_SIZE_LIMITS as W, headerVariantValues as Wn, resolveTokenOrCssColorValue as Wr, runWithInvocation as Wt, stableStringify as X, eventListTreatmentValues as Xn, textColorStyle as Xr, parseEnvironmentSelection as Xt, sortRecord as Y, defineNoBlockDesignCapability as Yn, rgbColorValue as Yr, executeEnvironmentPlan as Yt, createDryRunReport as Z, eyebrowTreatmentValues as Zn, resolveSurfaceForeground as Zr, planEnvironmentExecution as Zt, extractMediaIdentifiers as _, ORDINARY_TEXT_MIN_CONTRAST_RATIO as _i, GRADIENT_PRESET_IDS as _n, LABEL_FONT_SIZE_MAP as _r, createContentEntryRef as _t, syncLocalMediaForPull as a, parseThemeForPersistence as ai, getEnvironmentDebugInfo as an, getComponentBorderWidthPx as ar, entryIdentifierForCommand as at, hasOwnSettingsField as b, VARIANT_ROLES as bi, boundaryRuntimeMetricsForTransition as bn, ACCORDION_TRIGGER_FONT_SCALE as br, createFooterRef as bt, admitBinaryWriteDestination as c, generateShadowValue$1 as ci, loadSdkEnvironment as cn, parseCustomCssRules as cr, pagePathForCommand as ct, sha256 as d, surfaceForegroundStyle as di, ManagementApiError as dn, NAV_LINK_PADDING_MAP as dr, require_react as dt, generateBaseInteractiveCSS as ei, withRiverbankEnv as en, introCompositionTreatmentValues as er, evaluateSiteCommandBatchExposure as et, normalizeMediaIdentifierInput as f, surfaceForegroundValue as fi, retargetCompiledBoundaryRuntimeForContentAdjacency as fn, NAV_LINK_PADDING_X_MAP as fr, pickShadeTowardBackground as ft, downloadMedia as g, getTextColorForBackground as gi, gradientToCss as gn, INPUT_SPACING_MAP as gr, createCommandRef as gt, buildStorageUrl as h, onColorTokenName as hi, getCuratedSiteStyle as hn, INPUT_FONT_SIZE_MAP as hr, createBlocksRef as ht, syncLocalMediaForPush as i, themeButtonClassName as ii, getEnvVarName as in, visibleHeadingDecorationFamilyValues as ir, blockOrderIdentifiersForCommand as it, parseAspectRatioValue as j, entryLinkSchema$1 as ji, generateHeaderScrollTreatmentStyles as jn, PUBLIC_BUTTON_ROLES as jr, createGetCommand as jt, normalizeWidthCandidates as k, RESOLVED_INTERNAL_LINK_ENTITY_TYPES as ki, boxBackgroundOverlaySchema as kn, cardVariantRoleValues as kr, createClientForEnv as kt, readStableBinaryFile as l, DEFAULT_SURFACE_TEXT_COLOR as li, createManagementClient as ln, NAV_LINK_BORDER_RADIUS_MAP as lr, hasConfiguredBookingVertical as lt, walkLocalContentMedia as m, isOnColorBackgroundCandidateToken as mi, readHeaderNavFontSizePreference as mn, FONT_WEIGHT_MAP as mr, createBlockRef as mt, createStyleCommand as n, TokenResolver as ni, CliExit as nn, testimonialsCompositionTreatmentValues as nr, getSiteCommandMetadata as nt, applyLocalMediaPush as o, compileButtonColourStates as oi, isLocalConfigured as on, getComponentShadowVar as or, pageIdentifierForBlockCommand as ot, normalizeMediaValueToIdentifierOnly as p, expandPalette as pi, mergeHeaderNavTypographyPreference as pn, NAV_LINK_TEXT_SIZE_MAP as pr, generateCssVars as pt, parseSafeDownloadFilename as q, defineBlockDesignCapability as qn, cssVarValue as qr, withErrorHandling as qt, revalidateLocalMediaPushPlan as r, parseThemeButtonVariantId as ri, getEnvPrefix as rn, tileTreatmentValues as rr, blockIdentifierForCommand as rt, prepareLocalMediaForPush as s, formatButtonColourContractError as si, isRemoteConfigured as sn, parseBlockCustomCssRules as sr, pageIdentifierForCommand as st, buildStyleSelectionInitializeCommandFromOptions as t, generateInteractiveChildInheritanceCSS as ti, formatError as tn, offeringsPreviewCompositionTreatmentValues as tr, evaluateSiteCommandExposure as tt, writeBinaryFileAtomic as u, surfaceForegroundDeclarations as ui, formatIgnoredDocumentSyncSectionWarning as un, NAV_LINK_LETTER_SPACING_MAP as ur, require_jsx_runtime as ut, SETTINGS_FILE_FIELDS as v, featuresFromHex as vi, getGradientPreset as vn, ACCORDION_OPEN_ACCENT_THICKNESS as vr, createEventCategoryRef as vt, buildRenderableMediaAssetIndex as w, mediaIdentifierSchema as wi, defaultThemeTokens as wn, generateCardCoreCss as wr, createSiteCommandSiteRef as wt, writeMediaManifest as x, buttonVariantIdSchema as xi, backgroundAppearanceColorTokenNames as xn, ACCORDION_TRIGGER_LETTER_SPACING as xr, createFormRef as xt, buildSettingsUpdateInput as y, hexToRgb$1 as yi, parseGradientPresetId as yn, ACCORDION_SPACING_MAP as yr, createEventSeriesRef as yt, deriveVideoSlotPolicy as z, pageLinkSchema$1 as zi, MQ_LG_UP as zn, deriveButtonSurfaceContext as zr, mapEntryForOutput as zt };