riverbankcms 0.5.0 → 0.7.0

package/dist/{src-DKm0bLEA.mjs → src-DT7DBZtQ.mjs}

@@ -52,7 +52,7 @@ const unsafeAsOccurrenceId = (id) => id;
 const unsafeAsEventOfferingId = (id) => id;
 const unsafeAsEventSeriesId = (id) => id;
 const unsafeAsEventPageRouteSlug = (value) => value;
-const unsafeAsTicketTypeId = (id) => id;
+const unsafeAsEventAttendeeTicketLineId = (id) => id;
 const unsafeAsEventSeriesRegistrationId = (id) => id;
 const unsafeAsEventCategoryId = (id) => id;
 const unsafeAsVenueId = (id) => id;
@@ -90,8 +90,6 @@ const unsafeAsFormId = (id) => id;
 const unsafeAsFormSubmissionId = (id) => id;
 const unsafeAsPassId = (id) => id;
 const unsafeAsMembershipId = (id) => id;
-const unsafeAsCourseId = (id) => id;
-const unsafeAsCourseProgramId = (id) => id;
 const unsafeAsCustomerId = (id) => id;
 const unsafeAsOrderId = (id) => id;
 const unsafeAsOrderItemId = (id) => id;
@@ -103,6 +101,9 @@ const unsafeAsOrderPaymentPlanInstalmentId = (id) => id;
 const unsafeAsManualPaymentOperationId = (id) => id;
 const unsafeAsCheckoutLineId = (id) => id;
 const unsafeAsAttendeeId = (id) => id;
+const unsafeAsEventRegistrationCommandId = (id) => id;
+const unsafeAsEventRegistrationCommandRowId = (id) => id;
+const unsafeAsEventRegistrationProjectionClaimToken = (id) => id;
 const unsafeAsCustomerPassId = (id) => id;
 const unsafeAsCustomerMembershipId = (id) => id;
 const unsafeAsAppointmentId = (id) => id;
@@ -160,8 +161,7 @@ const parsePageId = (value) => parseUuidBrand(value, unsafeAsPageId);
 const parsePageSurfaceId = (value) => parseUuidBrand(value, unsafeAsPageSurfaceId);
 const parseOccurrenceId = (value) => parseUuidBrand(value, unsafeAsOccurrenceId);
 const parseEventOfferingId = (value) => parseUuidBrand(value, unsafeAsEventOfferingId);
-const parseCourseProgramId = (value) => parseUuidBrand(value, unsafeAsCourseProgramId);
-const parseTicketTypeId = (value) => parseUuidBrand(value, unsafeAsTicketTypeId);
+const parseEventAttendeeTicketLineId = (value) => parseUuidBrand(value, unsafeAsEventAttendeeTicketLineId);
 const parsePricingOptionId = (value) => parseUuidBrand(value, unsafeAsPricingOptionId);
 const parseUserId = (value) => parseUuidBrand(value, unsafeAsUserId);
 const parseProductId = (value) => parseUuidBrand(value, unsafeAsProductId);
@@ -175,7 +175,8 @@ const parseNavigationMenuId = (value) => parseUuidBrand(value, unsafeAsNavigatio
 const parseNavigationItemId = (value) => parseUuidBrand(value, unsafeAsNavigationItemId);
 const parsePassId = (value) => parseUuidBrand(value, unsafeAsPassId);
 const parseMembershipId = (value) => parseUuidBrand(value, unsafeAsMembershipId);
-const parseCourseId = (value) => parseUuidBrand(value, unsafeAsCourseId);
+const asRetiredCourseId = (id) => id;
+const parseRetiredCourseId = (value) => parseUuidBrand(value, asRetiredCourseId);
 const parseFormId = (value) => parseUuidBrand(value, unsafeAsFormId);
 const parseAppointmentId = (value) => parseUuidBrand(value, unsafeAsAppointmentId);
 const parseAppointmentServiceId = (value) => parseUuidBrand(value, unsafeAsAppointmentServiceId);
@@ -183,6 +184,9 @@ const parseAppointmentResourceId = (value) => parseUuidBrand(value, unsafeAsAppo
 const parseAppointmentReservationId = (value) => parseUuidBrand(value, unsafeAsAppointmentReservationId);
 const parseAppointmentReservationRunId = (value) => parseUuidBrand(value, unsafeAsAppointmentReservationRunId);
 const parseAttendeeId = (value) => parseUuidBrand(value, unsafeAsAttendeeId);
+const parseEventRegistrationCommandId = (value) => parseUuidBrand(value, unsafeAsEventRegistrationCommandId);
+const parseEventRegistrationCommandRowId = (value) => parseUuidBrand(value, unsafeAsEventRegistrationCommandRowId);
+const parseEventRegistrationProjectionClaimToken = (value) => parseUuidBrand(value, unsafeAsEventRegistrationProjectionClaimToken);
 const parseDatedOfferingCapacityHoldId = (value) => parseUuidBrand(value, unsafeAsDatedOfferingCapacityHoldId);
 const parseDatedOfferingCapacityHoldAuditRef = (value) => parseUuidBrand(value, unsafeAsDatedOfferingCapacityHoldAuditRef);
 const parseDatedOfferingRevocationAuditEventId = (value) => parseUuidBrand(value, unsafeAsDatedOfferingRevocationAuditEventId);
@@ -475,6 +479,44 @@ function assertNever(value, message = "Unexpected variant") {
 	throw new Error(`${message}: ${String(value)}`);
 }
 
+//#endregion
+//#region ../core/src/event-booking-offer.ts
+const EVENT_PRICING_STRATEGIES = [
+	"free",
+	"single",
+	"tiered",
+	"sliding_scale"
+];
+function createEventBookingOffer(input) {
+	if (input.bookingRequirement === "none") {
+		return input.pricing.kind === "free" ? ok({
+			bookingRequirement: "none",
+			pricing: input.pricing,
+			paymentTerms: input.paymentTerms
+		}) : err({ kind: "paid_without_registration" });
+	}
+	if (input.bookingRequirement === "required") {
+		return ok({
+			bookingRequirement: "required",
+			pricing: input.pricing,
+			paymentTerms: input.paymentTerms
+		});
+	}
+	return err({
+		kind: "invalid_booking_requirement",
+		value: input.bookingRequirement
+	});
+}
+function eventPricingRequiresPayment(pricing) {
+	switch (pricing.kind) {
+		case "free": return false;
+		case "single": return true;
+		case "tiered": return pricing.options.some((option) => option.priceAmount > 0);
+		case "sliding_scale": return pricing.maximum > 0;
+		default: return assertNever(pricing);
+	}
+}
+
 //#endregion
 //#region ../core/src/currency-format.ts
 const CURRENCY_CODE_INPUT_PATTERN = /^[A-Za-z]{3}$/;
@@ -538,183 +580,6 @@ function formatCurrencyAmount(amountCents, currency, options) {
 	}
 }
 
-//#endregion
-//#region ../core/src/event-pricing.ts
-const EVENT_PRICING_MODES = [
-	"single",
-	"ticket_types",
-	"sliding_scale"
-];
-function isEventPricingMode(value) {
-	return typeof value === "string" && EVENT_PRICING_MODES.includes(value);
-}
-function publicEventPricingDisplay(pricing) {
-	return pricing.display;
-}
-function publicEventPricingType(pricing) {
-	switch (pricing.kind) {
-		case "drop_in":
-		case "free_registration": return "free";
-		case "single_paid":
-		case "ticket_types":
-		case "sliding_scale":
-		case "whole_series": return isFreePublicEventPriceDisplay(pricing.display) ? "free" : "paid";
-		case "external": return "external";
-	}
-}
-function publicEventPricingCurrency(pricing) {
-	switch (pricing.kind) {
-		case "drop_in":
-		case "free_registration":
-		case "single_paid":
-		case "ticket_types":
-		case "sliding_scale": return pricing.currency;
-		case "whole_series": return pricing.display.display.currency;
-		case "external": return null;
-	}
-}
-function publicEventScalarPrice(pricing) {
-	return pricing.kind === "single_paid" ? pricing.amount : null;
-}
-function publicEventPricingMode(pricing) {
-	switch (pricing.kind) {
-		case "single_paid":
-		case "free_registration": return "single";
-		case "ticket_types": return "ticket_types";
-		case "sliding_scale": return "sliding_scale";
-		case "drop_in":
-		case "whole_series":
-		case "external": return undefined;
-	}
-}
-function publicEventTicketTypes(pricing) {
-	return pricing.kind === "ticket_types" ? pricing.ticketTypes : [];
-}
-function isFreePublicEventPriceDisplay(display) {
-	switch (display.kind) {
-		case "free": return true;
-		case "whole_series": return display.display.kind === "free";
-		case "exact":
-		case "from":
-		case "range":
-		case "mixed":
-		case "unavailable":
-		case "external": return false;
-	}
-}
-function formatCoursePriceDisplayLabel(display, options) {
-	switch (display.kind) {
-		case "free":
-		case "unavailable": return "Course";
-		case "exact": return `Course (${formatCurrencyAmount(display.amount, display.currency, options)})`;
-		case "from": return `Course (From ${formatCurrencyAmount(display.amount, display.currency, options)})`;
-		case "range": return `Course (${formatCurrencyAmount(display.minAmount, display.currency, options)} - ${formatCurrencyAmount(display.maxAmount, display.currency, options)})`;
-		case "mixed": return display.paidToAmount > display.paidFromAmount ? `Course (Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)} - ${formatCurrencyAmount(display.paidToAmount, display.currency, options)})` : `Course (Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)})`;
-		default: return assertNever(display);
-	}
-}
-/**
-* The single renderer for a precomputed booking price `display` ADT. This is
-* the one place booking price variants map to user-facing strings — every call
-* site (booking entry, events calendar, event/course details, listings, portal)
-* should route through here so labels never drift. Adding a variant to the ADT
-* breaks compilation here (via `assertNever`) until it is handled.
-*/
-function formatBookingPriceDisplay(display, options = {}) {
-	switch (display.kind) {
-		case "free": return "Free";
-		case "exact": return formatCurrencyAmount(display.amount, display.currency, options);
-		case "from": return `From ${formatCurrencyAmount(display.amount, display.currency, options)}`;
-		case "range": return `${formatCurrencyAmount(display.minAmount, display.currency, options)} - ${formatCurrencyAmount(display.maxAmount, display.currency, options)}`;
-		case "mixed": return display.paidToAmount > display.paidFromAmount ? `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)} - ${formatCurrencyAmount(display.paidToAmount, display.currency, options)}` : `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)}`;
-		case "unavailable": return "Pricing unavailable";
-		case "external": return display.label;
-		case "whole_series": return formatCoursePriceDisplayLabel(display.display, options);
-		default: return assertNever(display);
-	}
-}
-/** Render an event's price directly from its pricing value. */
-function formatEventPricing(pricing, options = {}) {
-	return formatBookingPriceDisplay(publicEventPricingDisplay(pricing), options);
-}
-
-//#endregion
-//#region ../core/src/event-page-surface-subject.ts
-function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope) {
-	return bookingScope === "whole_series" ? {
-		kind: "eventSeries",
-		eventSeriesId,
-		bookingScope,
-		isWholeSeriesBooking: true
-	} : {
-		kind: "eventSeries",
-		eventSeriesId,
-		bookingScope
-	};
-}
-function parseEventPageSurfaceSubject(value) {
-	if (!isRecord$6(value)) return err({ kind: "notObject" });
-	switch (value.kind) {
-		case "eventSeries": {
-			const eventSeriesId = parseEventSeriesId(value.eventSeriesId);
-			if (!eventSeriesId.ok) {
-				return err({
-					kind: "invalidEventSeriesId",
-					error: eventSeriesId.error
-				});
-			}
-			if (value.bookingScope !== "single_occurrence" && value.bookingScope !== "whole_series") {
-				return err({
-					kind: "invalidEventSeriesBookingScope",
-					bookingScope: value.bookingScope
-				});
-			}
-			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
-		}
-		case "eventOffering": {
-			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
-			if (!eventOfferingId.ok) {
-				return err({
-					kind: "invalidEventOfferingId",
-					error: eventOfferingId.error
-				});
-			}
-			if (!Array.isArray(value.availableEventSeriesIds)) {
-				return err({
-					kind: "unsupportedSubject",
-					subjectKind: value.kind
-				});
-			}
-			const parsedSeriesIds = [];
-			for (const valueId of value.availableEventSeriesIds) {
-				const eventSeriesId = parseEventSeriesId(valueId);
-				if (!eventSeriesId.ok) {
-					return err({
-						kind: "invalidEventSeriesId",
-						error: eventSeriesId.error
-					});
-				}
-				parsedSeriesIds.push(eventSeriesId.value);
-			}
-			return ok({
-				kind: "eventOffering",
-				eventOfferingId: eventOfferingId.value,
-				availableEventSeriesIds: parsedSeriesIds
-			});
-		}
-		default: return err({
-			kind: "unsupportedSubject",
-			subjectKind: value.kind
-		});
-	}
-}
-function toEventPageSurfaceSubjectWire(subject) {
-	return subject;
-}
-function isRecord$6(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 //#endregion
 //#region ../core/src/money-input.ts
 function unsafeAsCents(value) {
@@ -843,6 +708,675 @@ function formatMoneyInputFromCents(amountCents) {
 	return `${sign}${units}.${fractional}`;
 }
 
+//#endregion
+//#region ../core/src/non-empty-array.ts
+function fromArray(items) {
+	const [first, ...rest] = items;
+	if (first === undefined) {
+		return err("empty_array");
+	}
+	return ok([first, ...rest]);
+}
+function mapNonEmptyArray(items, map) {
+	return items.map(map);
+}
+function fromReadonlyArray(items) {
+	const [first, ...rest] = items;
+	return first === undefined ? err("empty_array") : ok([first, ...rest]);
+}
+function mapReadonlyNonEmptyArray(items, map) {
+	const [first, ...rest] = items;
+	return [map(first, 0), ...rest.map((item, index) => map(item, index + 1))];
+}
+
+//#endregion
+//#region ../core/src/event-booking-offer-parser.ts
+function oneIssue(issue) {
+	return [issue];
+}
+function isNullish(value) {
+	return value === null || value === undefined;
+}
+function parseOptionIdentity(input) {
+	const id = parsePricingOptionId(input.id);
+	if (!id.ok) return err({ kind: "invalid_id" });
+	if (typeof input.name !== "string" || input.name.trim().length === 0) {
+		return err({ kind: "invalid_name" });
+	}
+	if (!isNullish(input.description) && typeof input.description !== "string") {
+		return err({ kind: "invalid_description" });
+	}
+	return ok({
+		id: id.value,
+		name: input.name.trim(),
+		description: input.description ?? null
+	});
+}
+function parseOptionCommercials(input) {
+	const price = typeof input.priceAmount === "number" ? parseNonNegativeCents(input.priceAmount) : err({ kind: "invalid-number" });
+	if (!price.ok) return err({
+		kind: "invalid_price",
+		error: price.error
+	});
+	if (typeof input.isActive !== "boolean") return err({ kind: "invalid_active" });
+	if (typeof input.sortOrder !== "number" || !Number.isInteger(input.sortOrder) || input.sortOrder < 0) {
+		return err({ kind: "invalid_sort_order" });
+	}
+	if (!isNullish(input.capacityLimit) && (typeof input.capacityLimit !== "number" || !Number.isInteger(input.capacityLimit) || input.capacityLimit < 1)) {
+		return err({ kind: "invalid_capacity" });
+	}
+	return ok({
+		priceAmount: price.value,
+		isActive: input.isActive,
+		sortOrder: input.sortOrder,
+		capacityLimit: input.capacityLimit ?? null
+	});
+}
+function parseNullableIsoDateTime(value, issue) {
+	if (isNullish(value)) return ok(null);
+	if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
+		return err({ kind: issue });
+	}
+	return ok(value);
+}
+function parseAttendanceScope(value) {
+	if (value === "in_person" || value === "online" || value === "both") {
+		return ok(value);
+	}
+	return err({ kind: "invalid_attendance_scope" });
+}
+function parseRecipeIdentifier(value) {
+	if (isNullish(value)) return ok(null);
+	if (typeof value !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(value)) {
+		return err({ kind: "invalid_recipe_identifier" });
+	}
+	return ok(value);
+}
+function parseOptionAvailability(input) {
+	const start = parseNullableIsoDateTime(input.saleStartsAt, "invalid_sale_start");
+	if (!start.ok) return start;
+	const end = parseNullableIsoDateTime(input.saleEndsAt, "invalid_sale_end");
+	if (!end.ok) return end;
+	if (start.value !== null && end.value !== null && Date.parse(end.value) <= Date.parse(start.value)) {
+		return err({ kind: "invalid_sale_window" });
+	}
+	const scope = parseAttendanceScope(input.attendanceScope);
+	if (!scope.ok) return scope;
+	const recipe = parseRecipeIdentifier(input.recipeIdentifier);
+	if (!recipe.ok) return recipe;
+	return ok({
+		saleStartsAt: start.value,
+		saleEndsAt: end.value,
+		attendanceScope: scope.value,
+		recipeIdentifier: recipe.value
+	});
+}
+function parseEventPricingOption(input) {
+	const identity = parseOptionIdentity(input);
+	const commercials = parseOptionCommercials(input);
+	const availability$1 = parseOptionAvailability(input);
+	const issues = [
+		identity,
+		commercials,
+		availability$1
+	].flatMap((result) => result.ok ? [] : [result.error]);
+	if (!identity.ok || !commercials.ok || !availability$1.ok) {
+		const nonEmptyIssues = fromReadonlyArray(issues);
+		return err(nonEmptyIssues.ok ? nonEmptyIssues.value : oneIssue({ kind: "invalid_object" }));
+	}
+	return ok({
+		...identity.value,
+		...commercials.value,
+		...availability$1.value
+	});
+}
+function unexpectedValues(input, fields) {
+	return fields.flatMap((field) => isNullish(input[field]) ? [] : [{
+		kind: "unexpected_value",
+		field
+	}]);
+}
+function invalidOptionsIssue(value) {
+	return Array.isArray(value) && value.length === 0 ? [] : [{
+		kind: "unexpected_value",
+		field: "options"
+	}];
+}
+function parseFreePricing(input, currency) {
+	const issues = [...unexpectedValues(input, [
+		"singlePriceAmount",
+		"slidingMinAmount",
+		"slidingMaxAmount",
+		"slidingSuggestedAmount"
+	]), ...invalidOptionsIssue(input.options)];
+	const nonEmptyIssues = fromReadonlyArray(issues);
+	return nonEmptyIssues.ok ? err(nonEmptyIssues.value) : ok({
+		kind: "free",
+		currency
+	});
+}
+function parseSinglePricing(input, currency) {
+	const amount = typeof input.singlePriceAmount === "number" ? parsePositiveCents(input.singlePriceAmount) : err({ kind: "invalid-number" });
+	const issues = [
+		...unexpectedValues(input, [
+			"slidingMinAmount",
+			"slidingMaxAmount",
+			"slidingSuggestedAmount"
+		]),
+		...invalidOptionsIssue(input.options),
+		...amount.ok ? [] : [{
+			kind: "invalid_amount",
+			field: "singlePriceAmount",
+			error: amount.error
+		}]
+	];
+	const nonEmptyIssues = fromReadonlyArray(issues);
+	if (nonEmptyIssues.ok) return err(nonEmptyIssues.value);
+	if (!amount.ok) return err(oneIssue({
+		kind: "invalid_amount",
+		field: "singlePriceAmount",
+		error: amount.error
+	}));
+	return ok({
+		kind: "single",
+		currency,
+		amount: amount.value
+	});
+}
+function parseRawPricingOption(raw, index) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+		return err(oneIssue({
+			kind: "invalid_option",
+			index,
+			issue: { kind: "invalid_object" }
+		}));
+	}
+	const parsed = parseEventPricingOption(raw);
+	if (parsed.ok) return parsed;
+	const [first, ...rest] = parsed.error;
+	return err([{
+		kind: "invalid_option",
+		index,
+		issue: first
+	}, ...rest.map((issue) => ({
+		kind: "invalid_option",
+		index,
+		issue
+	}))]);
+}
+function parseTieredPricing(input, currency) {
+	const structuralIssues = unexpectedValues(input, [
+		"singlePriceAmount",
+		"slidingMinAmount",
+		"slidingMaxAmount",
+		"slidingSuggestedAmount"
+	]);
+	if (!Array.isArray(input.options) || input.options.length === 0) {
+		return err([{ kind: "tiered_options_empty" }, ...structuralIssues]);
+	}
+	const parsed = input.options.map(parseRawPricingOption);
+	const issues = [...structuralIssues, ...parsed.flatMap((result) => result.ok ? [] : result.error)];
+	const nonEmptyIssues = fromReadonlyArray(issues);
+	if (nonEmptyIssues.ok) return err(nonEmptyIssues.value);
+	const options = parsed.flatMap((result) => result.ok ? [result.value] : []);
+	const nonEmptyOptions = fromReadonlyArray(options);
+	if (!nonEmptyOptions.ok) {
+		return err(oneIssue({ kind: "tiered_options_empty" }));
+	}
+	return ok({
+		kind: "tiered",
+		currency,
+		options: nonEmptyOptions.value
+	});
+}
+function amountIssue(field, result) {
+	return result.ok ? [] : [{
+		kind: "invalid_amount",
+		field,
+		error: result.error
+	}];
+}
+function slidingRangeIssues(minimum, maximum, suggested) {
+	if (!minimum.ok || !maximum.ok || !suggested.ok) return [];
+	const issues = [];
+	if (minimum.value > maximum.value) issues.push({ kind: "invalid_sliding_range" });
+	if (suggested.value !== null && (suggested.value < minimum.value || suggested.value > maximum.value)) {
+		issues.push({ kind: "suggested_outside_range" });
+	}
+	return issues;
+}
+function parseSlidingPricing(input, currency) {
+	const minimum = typeof input.slidingMinAmount === "number" ? parseNonNegativeCents(input.slidingMinAmount) : err({ kind: "invalid-number" });
+	const maximum = typeof input.slidingMaxAmount === "number" ? parsePositiveCents(input.slidingMaxAmount) : err({ kind: "invalid-number" });
+	const suggested = isNullish(input.slidingSuggestedAmount) ? ok(null) : typeof input.slidingSuggestedAmount === "number" ? parseNonNegativeCents(input.slidingSuggestedAmount) : err({ kind: "invalid-number" });
+	const issues = [
+		...unexpectedValues(input, ["singlePriceAmount"]),
+		...invalidOptionsIssue(input.options),
+		...amountIssue("slidingMinAmount", minimum),
+		...amountIssue("slidingMaxAmount", maximum),
+		...amountIssue("slidingSuggestedAmount", suggested),
+		...slidingRangeIssues(minimum, maximum, suggested)
+	];
+	const nonEmptyIssues = fromReadonlyArray(issues);
+	if (nonEmptyIssues.ok) return err(nonEmptyIssues.value);
+	if (!minimum.ok) return err(oneIssue({
+		kind: "invalid_amount",
+		field: "slidingMinAmount",
+		error: minimum.error
+	}));
+	if (!maximum.ok) return err(oneIssue({
+		kind: "invalid_amount",
+		field: "slidingMaxAmount",
+		error: maximum.error
+	}));
+	if (!suggested.ok) return err(oneIssue({
+		kind: "invalid_amount",
+		field: "slidingSuggestedAmount",
+		error: suggested.error
+	}));
+	return ok({
+		kind: "sliding_scale",
+		currency,
+		minimum: minimum.value,
+		maximum: maximum.value,
+		suggested: suggested.value
+	});
+}
+function parseEventPricing(input) {
+	if (!isEventPricingStrategy(input.pricingStrategy)) {
+		return err(oneIssue({
+			kind: "invalid_strategy",
+			value: input.pricingStrategy
+		}));
+	}
+	const currency = typeof input.currency === "string" ? parseCurrencyCode(input.currency) : null;
+	if (currency === null) return err(oneIssue({
+		kind: "invalid_currency",
+		value: input.currency
+	}));
+	switch (input.pricingStrategy) {
+		case "free": return parseFreePricing(input, currency);
+		case "single": return parseSinglePricing(input, currency);
+		case "tiered": return parseTieredPricing(input, currency);
+		case "sliding_scale": return parseSlidingPricing(input, currency);
+		default: return assertNever(input.pricingStrategy);
+	}
+}
+function isEventPricingStrategy(value) {
+	return EVENT_PRICING_STRATEGIES.some((strategy) => strategy === value);
+}
+
+//#endregion
+//#region ../core/src/planner.ts
+function plannerNoChange(details = {}) {
+	return {
+		...details,
+		tag: "no_change"
+	};
+}
+function plannerUpdate(details = {}) {
+	return {
+		...details,
+		tag: "update"
+	};
+}
+/** Identity at runtime; marks a planner-derived patch as shallow readonly. */
+function plannerPatch(patch) {
+	return patch;
+}
+/** Default clock for production callers that do not inject time explicitly. */
+const systemPlanningClock = { now: () => Date.now() };
+/** Resolve current time from an explicit timestamp, injected clock, or system clock. */
+function resolvePlanningNow(input = {}) {
+	if (typeof input.now === "number") {
+		return input.now;
+	}
+	return (input.clock ?? systemPlanningClock).now();
+}
+/** Resolve current time as a Date from an explicit Date, injected clock, or system clock. */
+function resolvePlanningNowDate(input = {}) {
+	if (input.now !== undefined) {
+		return input.now;
+	}
+	return new Date((input.clock ?? systemPlanningClock).now());
+}
+/**
+* Resolve a Date-compatible planner input.
+*
+* Precedence: bare Date, `{ now }`, `{ clock }`, then `systemPlanningClock`.
+* Explicit Date inputs are returned by reference, not cloned.
+*/
+function resolvePlanningDateInput(input = {}) {
+	if (input instanceof Date) {
+		return input;
+	}
+	return resolvePlanningNowDate(input);
+}
+/** Build an enabled selection while preserving literal value types. */
+function enabledSelection(value) {
+	return {
+		enabled: true,
+		value
+	};
+}
+/** Build a disabled selection. */
+function disabledSelection() {
+	return { enabled: false };
+}
+
+//#endregion
+//#region ../core/src/event-pricing.ts
+/** Capacity closes booking, but does not make an otherwise eligible price unknown. */
+function isPublicEventPricingOptionDisplayable(option) {
+	if (!option.isActive) return false;
+	if (option.availability.kind === "available") return true;
+	const reason = option.availability.reason;
+	switch (reason) {
+		case "sold_out":
+		case "overallCapacityUnavailable": return true;
+		case "inactive":
+		case "not_on_sale_yet":
+		case "sale_ended":
+		case "attendance_mode_unavailable": return false;
+		default: return assertNever(reason);
+	}
+}
+function publicEventPricingDisplay(pricing) {
+	switch (pricing.kind) {
+		case "free":
+		case "single":
+		case "sliding_scale": return canonicalEventPricingDisplay(pricing);
+		case "tiered": return resolvePricingOptionsPriceDisplay({
+			options: pricing.options.filter(isPublicEventPricingOptionDisplayable),
+			currency: pricing.currency,
+			purpose: "configured"
+		});
+		case "external": return {
+			kind: "external",
+			label: pricing.label
+		};
+	}
+}
+function publicEventPricingType(pricing) {
+	switch (pricing.kind) {
+		case "free": return "free";
+		case "single":
+		case "tiered":
+		case "sliding_scale": return isFreePublicEventPriceDisplay(publicEventPricingDisplay(pricing)) ? "free" : "paid";
+		case "external": return "external";
+	}
+}
+function publicEventPricingCurrency(pricing) {
+	switch (pricing.kind) {
+		case "free":
+		case "single":
+		case "tiered":
+		case "sliding_scale": return pricing.currency;
+		case "external": return null;
+	}
+}
+function publicEventScalarPrice(pricing) {
+	return pricing.kind === "single" ? pricing.amount : null;
+}
+function publicEventPricingStrategy(pricing) {
+	switch (pricing.kind) {
+		case "single": return "single";
+		case "free": return "free";
+		case "tiered": return "tiered";
+		case "sliding_scale": return "sliding_scale";
+		case "external": return undefined;
+	}
+}
+function publicEventPricingOptions(pricing) {
+	return pricing.kind === "tiered" ? pricing.options : [];
+}
+function isFreePublicEventPriceDisplay(display) {
+	switch (display.kind) {
+		case "free": return true;
+		case "exact":
+		case "from":
+		case "range":
+		case "mixed":
+		case "unavailable":
+		case "external": return false;
+	}
+}
+function resolvePricingOptionSaleWindowState(option, now) {
+	if (option.saleStartsAt !== null && option.saleStartsAt !== undefined && new Date(option.saleStartsAt) > now) {
+		return "not_started";
+	}
+	if (option.saleEndsAt !== null && option.saleEndsAt !== undefined && new Date(option.saleEndsAt) < now) {
+		return "ended";
+	}
+	return "open";
+}
+function resolveExactOrFreePriceDisplay(amount, currency) {
+	const resolvedAmount = amount ?? 0;
+	return resolvedAmount > 0 ? {
+		kind: "exact",
+		amount: resolvedAmount,
+		currency
+	} : {
+		kind: "free",
+		currency
+	};
+}
+function resolvePricingOptionsPriceDisplay(input) {
+	const now = input.purpose === "available_now" ? resolvePlanningNowDate({
+		now: input.now,
+		clock: input.clock
+	}) : null;
+	const amounts = input.options.filter((option) => option.isActive && (now === null || resolvePricingOptionSaleWindowState(option, now) === "open")).map((option) => option.priceAmount);
+	return amounts.length === 0 ? {
+		kind: "unavailable",
+		currency: input.currency
+	} : amountRangeDisplay(amounts, input.currency);
+}
+function amountRangeDisplay(amounts, currency) {
+	const minAmount = Math.min(...amounts);
+	const maxAmount = Math.max(...amounts);
+	if (minAmount === maxAmount) {
+		return minAmount === 0 ? {
+			kind: "free",
+			currency
+		} : {
+			kind: "exact",
+			amount: minAmount,
+			currency
+		};
+	}
+	if (minAmount === 0) {
+		const paidAmounts = amounts.filter((amount) => amount > 0);
+		return {
+			kind: "mixed",
+			paidFromAmount: Math.min(...paidAmounts),
+			paidToAmount: maxAmount,
+			currency
+		};
+	}
+	return {
+		kind: "range",
+		minAmount,
+		maxAmount,
+		currency
+	};
+}
+/** Derives configured price presentation directly from canonical pricing. */
+function canonicalEventPricingDisplay(pricing) {
+	switch (pricing.kind) {
+		case "free": return {
+			kind: "free",
+			currency: pricing.currency
+		};
+		case "single": return {
+			kind: "exact",
+			amount: pricing.amount,
+			currency: pricing.currency
+		};
+		case "sliding_scale": return pricing.minimum === pricing.maximum ? {
+			kind: "exact",
+			amount: pricing.maximum,
+			currency: pricing.currency
+		} : {
+			kind: "range",
+			minAmount: pricing.minimum,
+			maxAmount: pricing.maximum,
+			currency: pricing.currency
+		};
+		case "tiered": {
+			return resolvePricingOptionsPriceDisplay({
+				options: pricing.options,
+				currency: pricing.currency,
+				purpose: "configured"
+			});
+		}
+		default: return assertNever(pricing);
+	}
+}
+/**
+* The single renderer for a precomputed booking price `display` ADT. This is
+* the one place booking price variants map to user-facing strings — every call
+* site (booking entry, events calendar, event/course details, listings, portal)
+* should route through here so labels never drift. Adding a variant to the ADT
+* breaks compilation here (via `assertNever`) until it is handled.
+*/
+function formatBookingPriceDisplay(display, options = {}) {
+	switch (display.kind) {
+		case "free": return "Free";
+		case "exact": return formatCurrencyAmount(display.amount, display.currency, options);
+		case "from": return `From ${formatCurrencyAmount(display.amount, display.currency, options)}`;
+		case "range": return `${formatCurrencyAmount(display.minAmount, display.currency, options)} - ${formatCurrencyAmount(display.maxAmount, display.currency, options)}`;
+		case "mixed": return display.paidToAmount > display.paidFromAmount ? `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)} - ${formatCurrencyAmount(display.paidToAmount, display.currency, options)}` : `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)}`;
+		case "unavailable": return "Pricing unavailable";
+		case "external": return display.label;
+		default: return assertNever(display);
+	}
+}
+/** Render an event's price directly from its pricing value. */
+function formatEventPricing(pricing, options = {}) {
+	return formatBookingPriceDisplay(publicEventPricingDisplay(pricing), options);
+}
+
+//#endregion
+//#region ../core/src/event-page-surface-subject.ts
+function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope, eventDestinationMode) {
+	const mode = eventDestinationMode ? { eventDestinationMode } : {};
+	return bookingScope === "whole_series" ? {
+		kind: "eventSeries",
+		eventSeriesId,
+		bookingScope,
+		isWholeSeriesBooking: true,
+		...mode
+	} : {
+		kind: "eventSeries",
+		eventSeriesId,
+		bookingScope,
+		...mode
+	};
+}
+function createEventOfferingPageSurfaceSubject(eventOfferingId, input) {
+	const mode = input.eventDestinationMode ? { eventDestinationMode: input.eventDestinationMode } : {};
+	const identity = {
+		kind: "eventOffering",
+		eventOfferingId,
+		catalogueEventSeriesIds: input.catalogueEventSeriesIds
+	};
+	return input.bookingScope === "whole_series" ? {
+		...identity,
+		bookingScope: input.bookingScope,
+		isWholeSeriesBooking: true,
+		...mode
+	} : {
+		...identity,
+		bookingScope: input.bookingScope,
+		...mode
+	};
+}
+/**
+* Read the destination mode off a wire value.
+*
+* Absent or unrecognised reads as absent, which leaves the routed Event record
+* as the only authority — the behaviour every caller had before the field
+* existed.
+*/
+function parseEventPageSurfaceDestinationMode(value) {
+	return value === "cms-managed" || value === "system-managed" ? value : undefined;
+}
+function parseEventPageSurfaceSubject(value) {
+	if (!isRecord$8(value)) return err({ kind: "notObject" });
+	switch (value.kind) {
+		case "eventSeries": {
+			const eventSeriesId = parseEventSeriesId(value.eventSeriesId);
+			if (!eventSeriesId.ok) {
+				return err({
+					kind: "invalidEventSeriesId",
+					error: eventSeriesId.error
+				});
+			}
+			if (value.bookingScope !== "single_occurrence" && value.bookingScope !== "whole_series") {
+				return err({
+					kind: "invalidEventSeriesBookingScope",
+					bookingScope: value.bookingScope
+				});
+			}
+			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope, parseEventPageSurfaceDestinationMode(value.eventDestinationMode)));
+		}
+		case "eventOffering": {
+			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
+			if (!eventOfferingId.ok) {
+				return err({
+					kind: "invalidEventOfferingId",
+					error: eventOfferingId.error
+				});
+			}
+			if (!Array.isArray(value.catalogueEventSeriesIds)) {
+				return err({
+					kind: "invalidEventOfferingCatalogue",
+					catalogue: value.catalogueEventSeriesIds
+				});
+			}
+			if (value.bookingScope !== "single_occurrence" && value.bookingScope !== "whole_series") {
+				return err({
+					kind: "invalidEventOfferingBookingScope",
+					bookingScope: value.bookingScope
+				});
+			}
+			const parsedCatalogueIds = parseEventSeriesIdList(value.catalogueEventSeriesIds);
+			if (!parsedCatalogueIds.ok) return parsedCatalogueIds;
+			const eventDestinationMode = parseEventPageSurfaceDestinationMode(value.eventDestinationMode);
+			return ok(createEventOfferingPageSurfaceSubject(eventOfferingId.value, {
+				catalogueEventSeriesIds: parsedCatalogueIds.value,
+				bookingScope: value.bookingScope,
+				...eventDestinationMode ? { eventDestinationMode } : {}
+			}));
+		}
+		default: return err({
+			kind: "unsupportedSubject",
+			subjectKind: value.kind
+		});
+	}
+}
+function toEventPageSurfaceSubjectWire(subject) {
+	return subject;
+}
+function parseEventSeriesIdList(values) {
+	const parsed = [];
+	for (const value of values) {
+		const eventSeriesId = parseEventSeriesId(value);
+		if (!eventSeriesId.ok) {
+			return err({
+				kind: "invalidEventSeriesId",
+				error: eventSeriesId.error
+			});
+		}
+		parsed.push(eventSeriesId.value);
+	}
+	return ok(parsed);
+}
+function isRecord$8(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 //#endregion
 //#region ../core/src/booking-flexible-balance.ts
 const DEFAULT_FLEXIBLE_BALANCE_STRIPE_MINIMUM_CHARGE_CENTS = 50;
@@ -1824,19 +2358,6 @@ function unwrapNarrow(result) {
 	return result.value;
 }
 
-//#endregion
-//#region ../core/src/non-empty-array.ts
-function fromArray(items) {
-	const [first, ...rest] = items;
-	if (first === undefined) {
-		return err("empty_array");
-	}
-	return ok([first, ...rest]);
-}
-function mapNonEmptyArray(items, map) {
-	return items.map(map);
-}
-
 //#endregion
 //#region ../core/src/editor-state.ts
 const unsafeAsEditorSiteId = (value) => value;
@@ -2718,7 +3239,7 @@ const knownSocialPlatforms = [
 	"x",
 	"youtube"
 ];
-function isRecord$5(value) {
+function isRecord$7(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function trimmedOptionalString(value) {
@@ -2728,7 +3249,7 @@ function trimmedOptionalString(value) {
 	return trimmed.length > 0 ? trimmed : null;
 }
 function parsePublicContactDetails(value) {
-	if (!isRecord$5(value)) {
+	if (!isRecord$7(value)) {
 		return err({
 			code: "invalid_shape",
 			path: "contact",
@@ -2824,7 +3345,7 @@ function minutesSinceMidnight(value) {
 }
 function parseOpeningHoursDay(value, expectedWeekday, index) {
 	const path = `openingHours.days.${index}`;
-	if (!isRecord$5(value) || value.weekday !== expectedWeekday) {
+	if (!isRecord$7(value) || value.weekday !== expectedWeekday) {
 		return err({
 			code: "invalid_weekdays",
 			path,
@@ -2845,7 +3366,7 @@ function parseOpeningHoursDay(value, expectedWeekday, index) {
 	const intervals = [];
 	for (const [intervalIndex, rawInterval] of value.intervals.entries()) {
 		const intervalPath = `${path}.intervals.${intervalIndex}`;
-		if (!isRecord$5(rawInterval)) {
+		if (!isRecord$7(rawInterval)) {
 			return err({
 				code: "invalid_interval",
 				path: intervalPath,
@@ -2895,7 +3416,7 @@ function parseOpeningHoursDay(value, expectedWeekday, index) {
 	});
 }
 function parseWeeklyOpeningHours(value) {
-	if (!isRecord$5(value) || !Array.isArray(value.days) || value.days.length !== publicProfileWeekdays.length) {
+	if (!isRecord$7(value) || !Array.isArray(value.days) || value.days.length !== publicProfileWeekdays.length) {
 		return err({
 			code: "invalid_weekdays",
 			path: "openingHours.days",
@@ -2975,7 +3496,7 @@ function parsePublicSocialLinks(value) {
 	const ids = new Set();
 	for (const [index, rawLink] of value.entries()) {
 		const path = `socialLinks.${index}`;
-		if (!isRecord$5(rawLink)) {
+		if (!isRecord$7(rawLink)) {
 			return err({
 				code: "invalid_social_link",
 				path,
@@ -3022,7 +3543,7 @@ function parsePublicSocialLinks(value) {
 	return ok(links);
 }
 function parsePublicProfile(value) {
-	if (!isRecord$5(value)) {
+	if (!isRecord$7(value)) {
 		return err({
 			code: "invalid_shape",
 			path: "",
@@ -3035,23 +3556,36 @@ function parsePublicProfile(value) {
 	if (!openingHours.ok) return openingHours;
 	const socialLinks = parsePublicSocialLinks(value.socialLinks);
 	if (!socialLinks.ok) return socialLinks;
+	const addressVisibility = parseAddressVisibility(value.addressVisibility);
+	if (!addressVisibility.ok) return addressVisibility;
 	return ok({
 		contact: contact.value,
 		openingHours: openingHours.value,
-		socialLinks: socialLinks.value
+		socialLinks: socialLinks.value,
+		addressVisibility: addressVisibility.value
+	});
+}
+function parseAddressVisibility(value) {
+	if (value === undefined || value === null) return ok("shown");
+	if (value === "shown" || value === "hidden") return ok(value);
+	return err({
+		code: "invalid_address_visibility",
+		path: "addressVisibility",
+		message: "Address visibility must be shown or hidden."
 	});
 }
 function emptyPublicProfile() {
 	return {
 		contact: null,
 		openingHours: null,
-		socialLinks: []
+		socialLinks: [],
+		addressVisibility: "shown"
 	};
 }
 
 //#endregion
 //#region ../core/src/rich-text.ts
-function isRecord$4(value) {
+function isRecord$6(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasOnlyKeys(value, allowed) {
@@ -3073,10 +3607,10 @@ function isDenseArrayOf(value, predicate) {
 	return true;
 }
 function isTipTapMark(value) {
-	return isRecord$4(value) && hasOnlyKeys(value, markKeys) && typeof value.type === "string" && value.type.length > 0 && (value.attrs === undefined || isRecord$4(value.attrs));
+	return isRecord$6(value) && hasOnlyKeys(value, markKeys) && typeof value.type === "string" && value.type.length > 0 && (value.attrs === undefined || isRecord$6(value.attrs));
 }
 function isTipTapNode(value) {
-	if (!isRecord$4(value) || !hasOnlyKeys(value, nodeKeys) || typeof value.type !== "string" || value.type.length === 0 || value.type === "doc" || value.attrs !== undefined && !isRecord$4(value.attrs) || value.marks !== undefined && (!Array.isArray(value.marks) || !isDenseArrayOf(value.marks, isTipTapMark)) || value.content !== undefined && (!Array.isArray(value.content) || !isDenseArrayOf(value.content, isTipTapNode))) {
+	if (!isRecord$6(value) || !hasOnlyKeys(value, nodeKeys) || typeof value.type !== "string" || value.type.length === 0 || value.type === "doc" || value.attrs !== undefined && !isRecord$6(value.attrs) || value.marks !== undefined && (!Array.isArray(value.marks) || !isDenseArrayOf(value.marks, isTipTapMark)) || value.content !== undefined && (!Array.isArray(value.content) || !isDenseArrayOf(value.content, isTipTapNode))) {
 		return false;
 	}
 	if (value.type === "text") {
@@ -3085,89 +3619,222 @@ function isTipTapNode(value) {
 	return value.text === undefined;
 }
 function isCanonicalRichTextDoc(value) {
-	return isRecord$4(value) && hasOnlyKeys(value, rootKeys) && value.type === "doc" && Array.isArray(value.content) && isDenseArrayOf(value.content, isTipTapNode);
+	return isRecord$6(value) && hasOnlyKeys(value, rootKeys) && value.type === "doc" && Array.isArray(value.content) && isDenseArrayOf(value.content, isTipTapNode);
 }
 
 //#endregion
-//#region ../core/src/newsletter-signup-destination.ts
+//#region ../core/src/mailing-list-identifiers.ts
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-const MAILCHIMP_AUDIENCE_ID_PATTERN = /^[A-Za-z0-9_-]{1,100}$/u;
+const OPAQUE_ID_PATTERN = /^[A-Za-z0-9_-]{1,100}$/u;
 const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/u;
-function isRecord$3(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parseTrimmedString(value) {
+function parseTrimmedMatchingString(value, pattern) {
 	if (typeof value !== "string") return null;
 	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : null;
+	return pattern.test(trimmed) ? trimmed : null;
+}
+function parsePositiveInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
 }
 function parseNewsletterListId(value) {
-	const trimmed = parseTrimmedString(value);
-	return trimmed !== null && UUID_PATTERN.test(trimmed) ? trimmed : null;
+	return parseTrimmedMatchingString(value, UUID_PATTERN);
 }
 function parseMailchimpConnectionId(value) {
-	const trimmed = parseTrimmedString(value);
-	return trimmed !== null && UUID_PATTERN.test(trimmed) ? trimmed : null;
+	return parseTrimmedMatchingString(value, UUID_PATTERN);
+}
+function parseMailchimpAccountId(value) {
+	return parseTrimmedMatchingString(value, OPAQUE_ID_PATTERN);
 }
 function parseMailchimpAudienceId(value) {
-	const trimmed = parseTrimmedString(value);
-	return trimmed !== null && MAILCHIMP_AUDIENCE_ID_PATTERN.test(trimmed) ? trimmed : null;
+	return parseTrimmedMatchingString(value, OPAQUE_ID_PATTERN);
+}
+function parseMailchimpInterestId(value) {
+	return parseTrimmedMatchingString(value, OPAQUE_ID_PATTERN);
+}
+function parseMailchimpTagName(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 && trimmed.length <= 100 && !CONTROL_CHARACTER_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseBrevoConnectionId(value) {
+	return parseTrimmedMatchingString(value, UUID_PATTERN);
+}
+function parseBrevoAccountId(value) {
+	return parseTrimmedMatchingString(value, OPAQUE_ID_PATTERN);
+}
+function parseBrevoListId(value) {
+	return parsePositiveInteger(value);
+}
+function parseBrevoConfirmationTemplateId(value) {
+	return parsePositiveInteger(value);
 }
-function parseMailchimpTagName(value) {
-	const trimmed = parseTrimmedString(value);
-	return trimmed !== null && trimmed.length <= 100 && !CONTROL_CHARACTER_PATTERN.test(trimmed) ? trimmed : null;
-}
-function parseNewsletterSignupDestinationProvider(value) {
-	return value === "riverbank" || value === "mailchimp" ? value : null;
-}
-function parseNewsletterSignupAuthoringDestinationValue(value) {
-	if (!isRecord$3(value) || typeof value.tag !== "string") {
-		return err({ kind: "invalid-destination-shape" });
-	}
-	switch (value.tag) {
-		case "riverbank_list": {
-			const listId = parseNewsletterListId(value.listId);
-			return listId === null ? err({ kind: "invalid-newsletter-list-id" }) : ok({
-				tag: "riverbank_list",
-				listId
+
+//#endregion
+//#region ../core/src/mailing-list-targeting-parser.ts
+function parseMailingListPlacementTargeting(value) {
+	if (!isRecord$5(value)) return targetingError("shape");
+	if (value.mode === "default") return ok({ mode: "default" });
+	if (value.mode !== "custom") return targetingError("mode");
+	if (!isRecord$5(value.selection)) return targetingError("selection");
+	switch (value.provider) {
+		case "native": return parseNativeTargeting(value.selection);
+		case "brevo": return parseBrevoTargeting(value.selection);
+		case "mailchimp": return parseMailchimpTargeting(value, value.selection);
+		default: return targetingError("provider");
+	}
+}
+function parseMailingListVisitorSelection(value) {
+	if (!isRecord$5(value)) return visitorSelectionError("shape");
+	switch (value.provider) {
+		case "native": {
+			const topicIds = parseVisitorIds(value.topicIds, parseNewsletterListId);
+			return topicIds === null ? visitorSelectionError("targets") : ok({
+				provider: "native",
+				topicIds
 			});
 		}
-		case "mailchimp_audience": {
-			const connectionId = parseMailchimpConnectionId(value.connectionId);
-			if (connectionId === null) {
-				return err({ kind: "invalid-mailchimp-connection-id" });
+		case "brevo": {
+			const listIds = parseVisitorIds(value.listIds, parseBrevoListId);
+			return listIds === null ? visitorSelectionError("targets") : ok({
+				provider: "brevo",
+				listIds
+			});
+		}
+		case "mailchimp": {
+			const interestIds = parseVisitorIds(value.interestIds, parseMailchimpInterestId);
+			return interestIds === null ? visitorSelectionError("targets") : ok({
+				provider: "mailchimp",
+				interestIds
+			});
+		}
+		default: return visitorSelectionError("provider");
+	}
+}
+function parseNativeTargeting(selection) {
+	if (selection.tag === "fixed") {
+		const topicIds = parseNonEmptyUniqueIds(selection.topicIds, parseNewsletterListId);
+		return topicIds.ok ? ok({
+			mode: "custom",
+			provider: "native",
+			selection: {
+				tag: "fixed",
+				topicIds: topicIds.value
 			}
-			const audienceId = parseMailchimpAudienceId(value.audienceId);
-			if (audienceId === null) {
-				return err({ kind: "invalid-mailchimp-audience-id" });
+		}) : topicIds;
+	}
+	if (selection.tag === "visitor_choice") {
+		const offeredTopicIds = parseNonEmptyUniqueIds(selection.offeredTopicIds, parseNewsletterListId);
+		return offeredTopicIds.ok ? ok({
+			mode: "custom",
+			provider: "native",
+			selection: {
+				tag: "visitor_choice",
+				offeredTopicIds: offeredTopicIds.value
 			}
-			const rawTags = value.tags ?? [];
-			if (!Array.isArray(rawTags)) {
-				return err({ kind: "invalid-mailchimp-tags" });
+		}) : offeredTopicIds;
+	}
+	return targetingError("selection");
+}
+function parseBrevoTargeting(selection) {
+	if (selection.tag === "fixed") {
+		const listIds = parseNonEmptyUniqueIds(selection.listIds, parseBrevoListId);
+		return listIds.ok ? ok({
+			mode: "custom",
+			provider: "brevo",
+			selection: {
+				tag: "fixed",
+				listIds: listIds.value
 			}
-			const tags = [];
-			for (const valueTag of rawTags) {
-				const tag = parseMailchimpTagName(valueTag);
-				if (tag === null) return err({ kind: "invalid-mailchimp-tags" });
-				tags.push(tag);
+		}) : listIds;
+	}
+	if (selection.tag === "visitor_choice") {
+		const offeredListIds = parseNonEmptyUniqueIds(selection.offeredListIds, parseBrevoListId);
+		return offeredListIds.ok ? ok({
+			mode: "custom",
+			provider: "brevo",
+			selection: {
+				tag: "visitor_choice",
+				offeredListIds: offeredListIds.value
 			}
-			return ok({
-				tag: "mailchimp_audience",
-				connectionId,
-				audienceId,
-				tags
-			});
-		}
-		default: return err({
-			kind: "invalid-destination-tag",
-			value: value.tag
-		});
+		}) : offeredListIds;
+	}
+	return targetingError("selection");
+}
+function parseMailchimpTargeting(value, selection) {
+	const audienceId = parseMailchimpAudienceId(value.audienceId);
+	if (audienceId === null) return targetingError("audienceId");
+	if (selection.tag === "fixed") {
+		const interestIds = parseUniqueIds(selection.interestIds, parseMailchimpInterestId);
+		return interestIds.ok ? ok({
+			mode: "custom",
+			provider: "mailchimp",
+			audienceId,
+			selection: {
+				tag: "fixed",
+				interestIds: interestIds.value
+			}
+		}) : interestIds;
+	}
+	if (selection.tag === "visitor_choice") {
+		const offeredInterestIds = parseNonEmptyUniqueIds(selection.offeredInterestIds, parseMailchimpInterestId);
+		return offeredInterestIds.ok ? ok({
+			mode: "custom",
+			provider: "mailchimp",
+			audienceId,
+			selection: {
+				tag: "visitor_choice",
+				offeredInterestIds: offeredInterestIds.value
+			}
+		}) : offeredInterestIds;
+	}
+	return targetingError("selection");
+}
+function parseNonEmptyUniqueIds(value, parseId) {
+	const parsed = parseUniqueIds(value, parseId);
+	if (!parsed.ok) return parsed;
+	const [first, ...rest] = parsed.value;
+	return first === undefined ? targetingError("targets") : ok([first, ...rest]);
+}
+function parseUniqueIds(value, parseId) {
+	if (!Array.isArray(value)) return targetingError("targets");
+	const parsed = [];
+	for (const item of value) {
+		const id = parseId(item);
+		if (id === null) return targetingError("targets");
+		if (parsed.includes(id)) return targetingError("duplicate_target");
+		parsed.push(id);
+	}
+	return ok(parsed);
+}
+function parseVisitorIds(value, parseId) {
+	if (!Array.isArray(value) || value.length === 0) return null;
+	const parsed = [];
+	for (const item of value) {
+		const id = parseId(item);
+		if (id === null) return null;
+		if (parsed.includes(id)) return null;
+		parsed.push(id);
 	}
+	return parsed;
+}
+function isRecord$5(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function targetingError(field) {
+	return err({
+		tag: "invalid_mailing_list_targeting",
+		field
+	});
+}
+function visitorSelectionError(field) {
+	return err({
+		tag: "invalid_mailing_list_visitor_selection",
+		field
+	});
 }
 
 //#endregion
 //#region ../core/src/footer-engagement.ts
-function isRecord$2(value) {
+function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function invalid(path, message) {
@@ -3201,7 +3868,7 @@ function parseEngagementBase(value, base, path) {
 	}
 	const treatment = parseTreatment(value.treatment, `${path}.treatment`);
 	if (!treatment.ok) return treatment;
-	if (!isRecord$2(value.source)) {
+	if (!isRecord$4(value.source)) {
 		return err(invalid(`${path}.source`, "Footer engagement source is invalid."));
 	}
 	const intro = parseBoundedText(value.source.intro, `${path}.source.intro`, {
@@ -3230,36 +3897,17 @@ function parseStandardContact(source, base, path) {
 }
 function parseMailingList(source, base, path) {
 	const { intro, ...section } = base;
-	const destination = parseNewsletterSignupAuthoringDestinationValue(source.destination);
-	if (!destination.ok) {
-		return err(invalid(`${path}.destination`, "Footer mailing-list destination is invalid."));
-	}
-	const buttonLabel = parseBoundedText(source.buttonLabel, `${path}.buttonLabel`, { maxLength: 40 });
-	if (!buttonLabel.ok) return buttonLabel;
-	const successMessage = parseBoundedText(source.successMessage, `${path}.successMessage`, { maxLength: 160 });
-	if (!successMessage.ok) return successMessage;
-	const privacyNote = parseBoundedText(source.privacyNote, `${path}.privacyNote`, {
-		maxLength: 240,
-		optional: true
-	});
-	if (!privacyNote.ok) return privacyNote;
-	if (buttonLabel.value === null || successMessage.value === null) {
-		return err(invalid(path, "Footer mailing-list copy cannot be empty."));
-	}
-	if (source.fieldPreset !== "emailOnly") {
-		return err(invalid(`${path}.fieldPreset`, "Footer mailing-list signup must be email-only."));
+	const targeting = parseMailingListPlacementTargeting(source.targeting);
+	if (!targeting.ok) {
+		return err(invalid(`${path}.targeting`, "Footer mailing-list targeting is invalid."));
 	}
 	return ok({
 		...section,
 		kind: "engagement",
 		source: {
 			kind: "mailing-list",
-			destination: destination.value,
-			intro,
-			buttonLabel: buttonLabel.value,
-			successMessage: successMessage.value,
-			privacyNote: privacyNote.value,
-			fieldPreset: "emailOnly"
+			targeting: targeting.value,
+			intro
 		}
 	});
 }
@@ -3267,7 +3915,7 @@ function parseFooterEngagementSectionValue(value, sectionBase, path) {
 	const base = parseEngagementBase(value, sectionBase, path);
 	if (!base.ok) return base;
 	const source = value.source;
-	if (!isRecord$2(source)) {
+	if (!isRecord$4(source)) {
 		return err(invalid(`${path}.source`, "Footer engagement source is invalid."));
 	}
 	switch (source.kind) {
@@ -3382,7 +4030,7 @@ function unsafeAsFooterModuleId(value) {
 function parseFooterModuleId(value) {
 	return parseSectionId(value, "sectionId");
 }
-function isRecord$1(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isRichText(value) {
@@ -3412,7 +4060,7 @@ function parseHeading(value, path) {
 }
 function parseFooterSection(value, index) {
 	const path = `sections.${index}`;
-	if (!isRecord$1(value)) {
+	if (!isRecord$3(value)) {
 		return err({
 			code: "invalid_section",
 			path,
@@ -3447,7 +4095,7 @@ function parseFooterSection(value, index) {
 			}
 			break;
 		case "navigation":
-			if (isRecord$1(value.source) && value.source.kind === "menu-role" && value.source.role === "main") {
+			if (isRecord$3(value.source) && value.source.kind === "menu-role" && value.source.role === "main") {
 				return ok({
 					...base,
 					kind: "navigation",
@@ -3460,7 +4108,7 @@ function parseFooterSection(value, index) {
 			}
 			break;
 		case "legal-navigation":
-			if (isRecord$1(value.source) && value.source.kind === "menu-role" && value.source.role === "legal-policy") {
+			if (isRecord$3(value.source) && value.source.kind === "menu-role" && value.source.role === "legal-policy") {
 				return ok({
 					...base,
 					kind: "legal-navigation",
@@ -3473,7 +4121,7 @@ function parseFooterSection(value, index) {
 			}
 			break;
 		case "business-address":
-			if (isRecord$1(value.source) && value.source.kind === "business-address") {
+			if (isRecord$3(value.source) && value.source.kind === "business-address") {
 				return ok({
 					...base,
 					kind: "business-address",
@@ -3485,7 +4133,7 @@ function parseFooterSection(value, index) {
 		case "contact":
 		case "opening-hours":
 		case "social-links":
-			if (isRecord$1(value.source) && value.source.kind === "public-profile") {
+			if (isRecord$3(value.source) && value.source.kind === "public-profile") {
 				return ok({
 					...base,
 					kind: value.kind,
@@ -3537,7 +4185,7 @@ function validateFooterComposition(composition) {
 	return ok(composition);
 }
 function parseFooterCompositionV1(value) {
-	if (!isRecord$1(value)) {
+	if (!isRecord$3(value)) {
 		return err({
 			code: "invalid_shape",
 			path: "",
@@ -3570,7 +4218,7 @@ function parseFooterCompositionV1(value) {
 	});
 }
 function parseLegacyPlacementSection(value, index, selectedIds) {
-	if (!isRecord$1(value)) {
+	if (!isRecord$3(value)) {
 		return err({
 			code: "invalid_section",
 			path: `modules.${index}`,
@@ -3578,7 +4226,7 @@ function parseLegacyPlacementSection(value, index, selectedIds) {
 		});
 	}
 	const selected = typeof value.id === "string" && selectedIds.has(value.id);
-	const source = isRecord$1(value.source) ? value.source : null;
+	const source = isRecord$3(value.source) ? value.source : null;
 	const mapped = value.kind === "navigation" && source?.kind === "menu-role" && source.role === "footer" ? {
 		...value,
 		source: {
@@ -3597,7 +4245,7 @@ function parseLegacyPlacementSection(value, index, selectedIds) {
 * It is intentionally not called by the runtime parser.
 */
 function upgradePlacementFooterCompositionV1(value) {
-	if (!isRecord$1(value) || value.schemaVersion !== 1 || !Array.isArray(value.modules) || !Array.isArray(value.placements)) {
+	if (!isRecord$3(value) || value.schemaVersion !== 1 || !Array.isArray(value.modules) || !Array.isArray(value.placements)) {
 		return err({
 			code: "invalid_shape",
 			path: "",
@@ -3606,7 +4254,7 @@ function upgradePlacementFooterCompositionV1(value) {
 	}
 	const selectedIds = new Set();
 	for (const [index, placement] of value.placements.entries()) {
-		if (!isRecord$1(placement) || typeof placement.moduleId !== "string") {
+		if (!isRecord$3(placement) || typeof placement.moduleId !== "string") {
 			return err({
 				code: "invalid_shape",
 				path: `placements.${index}`,
@@ -3709,8 +4357,8 @@ function repairTargetFor(section) {
 		};
 	}
 }
-function resolveFooterSections(composition, availability) {
-	return composition.sections.filter((section) => section.selected).map((section) => isSectionRenderable(section, availability) ? {
+function resolveFooterSections(composition, availability$1) {
+	return composition.sections.filter((section) => section.selected).map((section) => isSectionRenderable(section, availability$1) ? {
 		kind: "renderable",
 		section
 	} : {
@@ -3719,127 +4367,837 @@ function resolveFooterSections(composition, availability) {
 		repairTarget: repairTargetFor(section)
 	});
 }
-function isSectionRenderable(section, availability) {
-	switch (section.kind) {
-		case "brand": return section.showLogo && availability.hasLogo || section.showTitle;
-		case "navigation": return availability.hasMainNavigation;
-		case "legal-navigation": return availability.hasLegalPolicyNavigation;
-		case "business-address": return availability.hasBusinessAddress;
-		case "contact": return availability.hasContact;
-		case "opening-hours": return availability.hasOpeningHours;
-		case "social-links": return availability.hasSocialLinks;
-		case "engagement": return availability.hasEngagementSource;
-		case "supporting-text":
-		case "legal": return section.content !== null;
+function isSectionRenderable(section, availability$1) {
+	switch (section.kind) {
+		case "brand": return section.showLogo && availability$1.hasLogo || section.showTitle;
+		case "navigation": return availability$1.hasMainNavigation;
+		case "legal-navigation": return availability$1.hasLegalPolicyNavigation;
+		case "business-address": return availability$1.hasBusinessAddress;
+		case "contact": return availability$1.hasContact;
+		case "opening-hours": return availability$1.hasOpeningHours;
+		case "social-links": return availability$1.hasSocialLinks;
+		case "engagement": return availability$1.hasEngagementSource;
+		case "supporting-text":
+		case "legal": return section.content !== null;
+	}
+}
+function deriveFooterEditorOverview(composition) {
+	return {
+		selected: composition.sections.filter((section) => section.selected).map((section) => ({
+			section,
+			status: "selected"
+		})),
+		available: composition.sections.filter((section) => !section.selected).map((section) => ({
+			section,
+			status: "available"
+		}))
+	};
+}
+const defaultSections = (legacy, options) => {
+	const footerVisible = options.footerVisible ?? true;
+	return [
+		{
+			id: unsafeAsFooterModuleId("brand"),
+			kind: "brand",
+			heading: null,
+			selected: footerVisible,
+			showLogo: options.brand?.showLogo ?? true,
+			showTitle: options.brand?.showTitle ?? true
+		},
+		{
+			id: unsafeAsFooterModuleId("navigation"),
+			kind: "navigation",
+			heading: null,
+			selected: footerVisible,
+			source: {
+				kind: "menu-role",
+				role: "main"
+			}
+		},
+		{
+			id: unsafeAsFooterModuleId("legal-navigation"),
+			kind: "legal-navigation",
+			heading: null,
+			selected: false,
+			source: {
+				kind: "menu-role",
+				role: "legal-policy"
+			}
+		},
+		{
+			id: unsafeAsFooterModuleId("business-address"),
+			kind: "business-address",
+			heading: null,
+			selected: footerVisible && legacy.showBusinessAddress === true,
+			source: { kind: "business-address" }
+		},
+		{
+			id: unsafeAsFooterModuleId("contact"),
+			kind: "contact",
+			heading: null,
+			selected: false,
+			source: { kind: "public-profile" }
+		},
+		{
+			id: unsafeAsFooterModuleId("opening-hours"),
+			kind: "opening-hours",
+			heading: null,
+			selected: false,
+			source: { kind: "public-profile" }
+		},
+		{
+			id: unsafeAsFooterModuleId("social-links"),
+			kind: "social-links",
+			heading: null,
+			selected: false,
+			source: { kind: "public-profile" }
+		},
+		{
+			id: unsafeAsFooterModuleId("supporting-text"),
+			kind: "supporting-text",
+			heading: null,
+			selected: footerVisible && isRichText(legacy.bodyText),
+			content: isRichText(legacy.bodyText) ? legacy.bodyText : null
+		},
+		{
+			id: unsafeAsFooterModuleId("legal"),
+			kind: "legal",
+			heading: null,
+			selected: footerVisible && isRichText(legacy.bottomText),
+			content: isRichText(legacy.bottomText) ? legacy.bottomText : null
+		}
+	];
+};
+function normalizeLegacyFooterContentToV1(value, options = {}) {
+	if (!isRecord$3(value)) {
+		return err({
+			code: "invalid_shape",
+			path: "",
+			message: "Legacy footer content must be an object."
+		});
+	}
+	return validateFooterComposition({
+		schemaVersion: 1,
+		sections: defaultSections(value, options)
+	});
+}
+
+//#endregion
+//#region ../core/src/footer-navigation-layout.ts
+const footerNavigationLayouts = ["stack", "inline-wrap"];
+const defaultFooterNavigationLayout = "inline-wrap";
+function normalizeFooterNavigationLayout(value) {
+	return value === "stack" ? "stack" : defaultFooterNavigationLayout;
+}
+
+//#endregion
+//#region ../core/src/mailing-list-setup.ts
+function planMailingListFieldCompatibility(input) {
+	const collectedFields = resolveCollectedGlobalFields(input.form);
+	const requiredFields = resolveRequiredGlobalFields(input.form.fields);
+	const issues = [];
+	for (const destination of input.destinations) {
+		for (const field of destination.requiredFields) {
+			if (!collectedFields.includes(field)) {
+				issues.push({
+					tag: "destination_requires_uncollected_field",
+					destinationKey: destination.destinationKey,
+					field
+				});
+			} else if (!requiredFields.includes(field)) {
+				issues.push({
+					tag: "destination_requires_site_required_field",
+					destinationKey: destination.destinationKey,
+					field
+				});
+			}
+		}
+		for (const field of collectedFields) {
+			if (!destination.acceptedFields.includes(field)) {
+				issues.push({
+					tag: requiredFields.includes(field) ? "destination_rejects_required_site_field" : "destination_rejects_collected_site_field",
+					destinationKey: destination.destinationKey,
+					field
+				});
+			}
+		}
+	}
+	const [first, ...rest] = issues;
+	return first === undefined ? { tag: "compatible" } : {
+		tag: "blocked",
+		issues: [first, ...rest]
+	};
+}
+function resolveCollectedGlobalFields(form) {
+	const phone = form.includeOptionalPhone ? ["phone"] : [];
+	switch (form.fields.preset) {
+		case "emailOnly": return phone;
+		case "emailName": return ["name", ...phone];
+		case "emailFirstLast": return [
+			"first_name",
+			"last_name",
+			...phone
+		];
+		case "emailNameCompany": return [
+			"name",
+			"company",
+			...phone
+		];
+	}
+}
+function resolveRequiredGlobalFields(fields) {
+	switch (fields.preset) {
+		case "emailOnly": return [];
+		case "emailName": return fields.name === "required" ? ["name"] : [];
+		case "emailFirstLast": return [...fields.firstName === "required" ? ["first_name"] : [], ...fields.lastName === "required" ? ["last_name"] : []];
+		case "emailNameCompany": return [...fields.name === "required" ? ["name"] : [], ...fields.company === "required" ? ["company"] : []];
+	}
+}
+function planMailingListSetupSwitch(input) {
+	if (input.previousScope === null) {
+		return {
+			tag: "activate",
+			affectedPlacementCount: 0
+		};
+	}
+	if (sameProviderScope(input.previousScope, input.nextScope)) {
+		return {
+			tag: "update_same_scope",
+			affectedPlacementCount: input.defaultChanged ? countDefaultMailingListPlacements(input.placementModes) : 0
+		};
+	}
+	return {
+		tag: "replace_scope",
+		affectedPlacementCount: input.placementModes.length
+	};
+}
+function sameProviderScope(previous, next) {
+	if (previous.provider !== next.provider) return false;
+	switch (previous.provider) {
+		case "native": return true;
+		case "mailchimp": return next.provider === "mailchimp" && previous.accountId === next.accountId;
+		case "brevo": return next.provider === "brevo" && previous.accountId === next.accountId;
+	}
+}
+function countDefaultMailingListPlacements(placementModes) {
+	return placementModes.filter((mode) => mode === "default").length;
+}
+
+//#endregion
+//#region ../core/src/mailing-list-setup-parser.ts
+function parseMailingListGlobalForm(value) {
+	if (!isRecord$2(value)) return formError("shape");
+	const fields = parseGlobalFields(value.fields);
+	if (fields === null) return formError("fields");
+	if (typeof value.includeOptionalPhone !== "boolean") {
+		return formError("includeOptionalPhone");
+	}
+	const buttonLabel = parseRequiredString(value.buttonLabel);
+	if (buttonLabel === null) return formError("buttonLabel");
+	const privacyNote = parseOptionalString(value.privacyNote);
+	if (privacyNote === undefined) return formError("privacyNote");
+	return ok({
+		fields,
+		includeOptionalPhone: value.includeOptionalPhone,
+		buttonLabel,
+		privacyNote
+	});
+}
+function parseMailingListSiteSetup(value) {
+	if (!isRecord$2(value)) return setupError("shape");
+	const siteId = parseSiteId(value.siteId);
+	if (!siteId.ok) return setupError("siteId");
+	if (value.tag === "not_configured") {
+		return ok({
+			tag: "not_configured",
+			siteId: siteId.value
+		});
+	}
+	if (value.tag !== "configured") return setupError("tag");
+	const revision = parseMailingListSetupRevision(value.revision);
+	if (revision === null) return setupError("revision");
+	const form = parseMailingListGlobalForm(value.form);
+	if (!form.ok) return setupError("form");
+	const provider = parseConfiguredMailingListProvider(value.provider);
+	if (!provider.ok) return provider;
+	return ok({
+		tag: "configured",
+		siteId: siteId.value,
+		revision,
+		form: form.value,
+		provider: provider.value
+	});
+}
+function parseConfiguredMailingListProvider(value) {
+	if (!isRecord$2(value) || typeof value.provider !== "string") {
+		return setupError("provider");
+	}
+	switch (value.provider) {
+		case "native": {
+			const defaultTopicId = parseNewsletterListId(value.defaultTopicId);
+			if (defaultTopicId === null) return setupError("defaultTargetId");
+			const confirmation = parseToggleConfirmation(value.confirmation);
+			return confirmation === null ? setupError("confirmation") : ok({
+				provider: "native",
+				defaultTopicId,
+				confirmation
+			});
+		}
+		case "mailchimp": {
+			const connectionId = parseMailchimpConnectionId(value.connectionId);
+			if (connectionId === null) return setupError("connectionId");
+			const accountId = parseMailchimpAccountId(value.accountId);
+			if (accountId === null) return setupError("accountId");
+			const defaultAudienceId = parseMailchimpAudienceId(value.defaultAudienceId);
+			if (defaultAudienceId === null) return setupError("defaultTargetId");
+			const confirmation = parseToggleConfirmation(value.confirmation);
+			return confirmation === null ? setupError("confirmation") : ok({
+				provider: "mailchimp",
+				connectionId,
+				accountId,
+				defaultAudienceId,
+				confirmation
+			});
+		}
+		case "brevo": {
+			const connectionId = parseBrevoConnectionId(value.connectionId);
+			if (connectionId === null) return setupError("connectionId");
+			const accountId = parseBrevoAccountId(value.accountId);
+			if (accountId === null) return setupError("accountId");
+			const defaultListId = parseBrevoListId(value.defaultListId);
+			if (defaultListId === null) return setupError("defaultTargetId");
+			const confirmation = parseBrevoConfirmation(value.confirmation);
+			return confirmation === null ? setupError("confirmation") : ok({
+				provider: "brevo",
+				connectionId,
+				accountId,
+				defaultListId,
+				confirmation
+			});
+		}
+		default: return setupError("provider");
+	}
+}
+function parseGlobalFields(value) {
+	if (!isRecord$2(value) || typeof value.preset !== "string") return null;
+	switch (value.preset) {
+		case "emailOnly": return { preset: "emailOnly" };
+		case "emailName": return isRequirement(value.name) ? {
+			preset: "emailName",
+			name: value.name
+		} : null;
+		case "emailFirstLast": return isRequirement(value.firstName) && isRequirement(value.lastName) ? {
+			preset: "emailFirstLast",
+			firstName: value.firstName,
+			lastName: value.lastName
+		} : null;
+		case "emailNameCompany": return isRequirement(value.name) && isRequirement(value.company) ? {
+			preset: "emailNameCompany",
+			name: value.name,
+			company: value.company
+		} : null;
+		default: return null;
+	}
+}
+function parseToggleConfirmation(value) {
+	if (!isRecord$2(value)) return null;
+	return value.tag === "on" || value.tag === "off" ? { tag: value.tag } : null;
+}
+function parseBrevoConfirmation(value) {
+	if (!isRecord$2(value)) return null;
+	if (value.tag === "off") return { tag: "off" };
+	if (value.tag !== "on") return null;
+	const templateId = parseBrevoConfirmationTemplateId(value.templateId);
+	const redirectUrl = parseHttpUrl(value.redirectUrl);
+	return templateId === null || redirectUrl === null ? null : {
+		tag: "on",
+		templateId,
+		redirectUrl
+	};
+}
+function parseMailingListSetupRevision(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function parseHttpUrl(value) {
+	if (typeof value !== "string") return null;
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : null;
+	} catch {
+		return null;
+	}
+}
+function parseRequiredString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function parseOptionalString(value) {
+	if (value === null || value === undefined) return null;
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function isRequirement(value) {
+	return value === "required" || value === "optional";
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formError(field) {
+	return err({
+		tag: "invalid_mailing_list_global_form",
+		field
+	});
+}
+function setupError(field) {
+	return err({
+		tag: "invalid_mailing_list_setup",
+		field
+	});
+}
+
+//#endregion
+//#region ../core/src/mailing-list-targeting.ts
+function sameMailingListPlacementTargeting(left, right) {
+	if (left.mode !== right.mode) return false;
+	if (left.mode === "default" || right.mode === "default") return true;
+	if (left.provider !== right.provider || left.selection.tag !== right.selection.tag) return false;
+	if (left.provider === "mailchimp" && (right.provider !== "mailchimp" || left.audienceId !== right.audienceId)) return false;
+	return sameIds(targetingSelectionIds(left), targetingSelectionIds(right));
+}
+function targetingSelectionIds(targeting) {
+	switch (targeting.provider) {
+		case "native": return targeting.selection.tag === "fixed" ? targeting.selection.topicIds : targeting.selection.offeredTopicIds;
+		case "brevo": return targeting.selection.tag === "fixed" ? targeting.selection.listIds : targeting.selection.offeredListIds;
+		case "mailchimp": return targeting.selection.tag === "fixed" ? targeting.selection.interestIds : targeting.selection.offeredInterestIds;
+	}
+}
+function sameIds(left, right) {
+	const leftIds = new Set(left);
+	const rightIds = new Set(right);
+	return leftIds.size === left.length && rightIds.size === right.length && leftIds.size === rightIds.size && [...leftIds].every((id) => rightIds.has(id));
+}
+function resolveMailingListTarget(input) {
+	if (input.targeting.mode === "default") {
+		if (input.visitorSelection !== undefined) {
+			return err({ tag: "visitor_selection_not_allowed" });
+		}
+		return ok(resolveDefaultTarget(input.setup));
+	}
+	if (input.targeting.provider !== input.setup.provider) {
+		return err({
+			tag: "targeting_provider_mismatch",
+			setupProvider: input.setup.provider,
+			targetingProvider: input.targeting.provider
+		});
+	}
+	return resolveCustomTarget(input.targeting, input.visitorSelection);
+}
+function resolveDefaultTarget(setup) {
+	switch (setup.provider) {
+		case "native": return {
+			provider: "native",
+			topicIds: [setup.defaultTopicId]
+		};
+		case "brevo": return {
+			provider: "brevo",
+			listIds: [setup.defaultListId]
+		};
+		case "mailchimp": return {
+			provider: "mailchimp",
+			audienceId: setup.defaultAudienceId,
+			interestIds: []
+		};
+	}
+}
+function resolveCustomTarget(targeting, visitorSelection) {
+	switch (targeting.provider) {
+		case "native": return resolveNativeTarget(targeting, visitorSelection);
+		case "brevo": return resolveBrevoTarget(targeting, visitorSelection);
+		case "mailchimp": return resolveMailchimpTarget(targeting, visitorSelection);
+	}
+}
+function resolveNativeTarget(targeting, selection) {
+	if (targeting.selection.tag === "fixed") {
+		return selection === undefined ? ok({
+			provider: "native",
+			topicIds: targeting.selection.topicIds
+		}) : err({ tag: "visitor_selection_not_allowed" });
+	}
+	if (selection === undefined) {
+		return targeting.selection.offeredTopicIds.length === 1 ? ok({
+			provider: "native",
+			topicIds: targeting.selection.offeredTopicIds
+		}) : err({ tag: "visitor_selection_required" });
+	}
+	if (selection.provider !== "native") {
+		return err({ tag: "visitor_selection_provider_mismatch" });
+	}
+	const selected = selectedNonEmptySubset(selection.topicIds, targeting.selection.offeredTopicIds);
+	return selected.ok ? ok({
+		provider: "native",
+		topicIds: selected.value
+	}) : err({ tag: "visitor_selection_outside_offer" });
+}
+function resolveBrevoTarget(targeting, selection) {
+	if (targeting.selection.tag === "fixed") {
+		return selection === undefined ? ok({
+			provider: "brevo",
+			listIds: targeting.selection.listIds
+		}) : err({ tag: "visitor_selection_not_allowed" });
+	}
+	if (selection === undefined) {
+		return targeting.selection.offeredListIds.length === 1 ? ok({
+			provider: "brevo",
+			listIds: targeting.selection.offeredListIds
+		}) : err({ tag: "visitor_selection_required" });
+	}
+	if (selection.provider !== "brevo") {
+		return err({ tag: "visitor_selection_provider_mismatch" });
+	}
+	const selected = selectedNonEmptySubset(selection.listIds, targeting.selection.offeredListIds);
+	return selected.ok ? ok({
+		provider: "brevo",
+		listIds: selected.value
+	}) : err({ tag: "visitor_selection_outside_offer" });
+}
+function resolveMailchimpTarget(targeting, selection) {
+	if (targeting.selection.tag === "fixed") {
+		return selection === undefined ? ok({
+			provider: "mailchimp",
+			audienceId: targeting.audienceId,
+			interestIds: targeting.selection.interestIds
+		}) : err({ tag: "visitor_selection_not_allowed" });
+	}
+	if (selection === undefined) {
+		return targeting.selection.offeredInterestIds.length === 1 ? ok({
+			provider: "mailchimp",
+			audienceId: targeting.audienceId,
+			interestIds: targeting.selection.offeredInterestIds
+		}) : err({ tag: "visitor_selection_required" });
+	}
+	if (selection.provider !== "mailchimp") {
+		return err({ tag: "visitor_selection_provider_mismatch" });
+	}
+	const subset = selectedNonEmptySubset(selection.interestIds, targeting.selection.offeredInterestIds);
+	return subset.ok ? ok({
+		provider: "mailchimp",
+		audienceId: targeting.audienceId,
+		interestIds: subset.value
+	}) : err({ tag: "visitor_selection_outside_offer" });
+}
+function selectedNonEmptySubset(selected, offered) {
+	const normalized = [...new Set(selected)];
+	const [first, ...rest] = normalized;
+	if (first === undefined || normalized.some((item) => !offered.includes(item))) {
+		return err("invalid_selection");
+	}
+	return ok([first, ...rest]);
+}
+function planMailingListChoicePresentation(targeting) {
+	if (targeting.mode === "default" || targeting.selection.tag === "fixed") {
+		return { tag: "hidden" };
+	}
+	switch (targeting.provider) {
+		case "native": return targeting.selection.offeredTopicIds.length === 1 ? {
+			tag: "automatic",
+			selection: {
+				provider: "native",
+				topicIds: targeting.selection.offeredTopicIds
+			}
+		} : {
+			tag: "visitor_choice",
+			provider: "native",
+			optionCount: targeting.selection.offeredTopicIds.length
+		};
+		case "brevo": return targeting.selection.offeredListIds.length === 1 ? {
+			tag: "automatic",
+			selection: {
+				provider: "brevo",
+				listIds: targeting.selection.offeredListIds
+			}
+		} : {
+			tag: "visitor_choice",
+			provider: "brevo",
+			optionCount: targeting.selection.offeredListIds.length
+		};
+		case "mailchimp": return targeting.selection.offeredInterestIds.length === 1 ? {
+			tag: "automatic",
+			selection: {
+				provider: "mailchimp",
+				interestIds: targeting.selection.offeredInterestIds
+			}
+		} : {
+			tag: "visitor_choice",
+			provider: "mailchimp",
+			optionCount: targeting.selection.offeredInterestIds.length
+		};
+	}
+}
+
+//#endregion
+//#region ../core/src/mailing-list-runtime.ts
+function parseMailingListRuntimeContext(value) {
+	if (!isRecord$1(value)) return invalidRuntimeContext();
+	if (value.tag === "not_configured") return ok({ tag: "not_configured" });
+	if (value.tag !== "configured") return invalidRuntimeContext();
+	const revision = parseMailingListSetupRevision(value.revision);
+	const form = parseMailingListGlobalForm(value.form);
+	const provider = parseRuntimeProvider(value.provider);
+	if (revision === null || !form.ok || provider === null) {
+		return invalidRuntimeContext();
 	}
+	return ok({
+		tag: "configured",
+		revision,
+		form: form.value,
+		provider
+	});
 }
-function deriveFooterEditorOverview(composition) {
+function parseRuntimeProvider(value) {
+	if (!isRecord$1(value)) return null;
+	switch (value.provider) {
+		case "native": return parseNativeRuntimeProvider(value);
+		case "brevo": return parseBrevoRuntimeProvider(value);
+		case "mailchimp": return parseMailchimpRuntimeProvider(value);
+		default: return null;
+	}
+}
+function parseNativeRuntimeProvider(value) {
+	const defaultTopicId = parseNewsletterListId(value.defaultTopicId);
+	const topics = parseNamedItems(value.topics, parseNewsletterListId);
+	return defaultTopicId !== null && topics !== null ? {
+		provider: "native",
+		defaultTopicId,
+		topics
+	} : null;
+}
+function parseBrevoRuntimeProvider(value) {
+	const defaultListId = parseBrevoListId(value.defaultListId);
+	const lists = parseNamedItems(value.lists, parseBrevoListId);
+	return defaultListId !== null && lists !== null ? {
+		provider: "brevo",
+		defaultListId,
+		lists
+	} : null;
+}
+function parseMailchimpRuntimeProvider(value) {
+	if (!Array.isArray(value.audiences)) return null;
+	const defaultAudienceId = parseMailchimpAudienceId(value.defaultAudienceId);
+	if (defaultAudienceId === null) return null;
+	const audiences = [];
+	for (const audience of value.audiences) {
+		if (!isRecord$1(audience)) return null;
+		const id = parseMailchimpAudienceId(audience.id);
+		const name = parseName(audience.name);
+		if (id === null || name === null || !Array.isArray(audience.interests)) {
+			return null;
+		}
+		const interests = parseMailchimpInterests(audience.interests);
+		if (interests === null) return null;
+		audiences.push({
+			id,
+			name,
+			interests
+		});
+	}
 	return {
-		selected: composition.sections.filter((section) => section.selected).map((section) => ({
-			section,
-			status: "selected"
-		})),
-		available: composition.sections.filter((section) => !section.selected).map((section) => ({
-			section,
-			status: "available"
-		}))
+		provider: "mailchimp",
+		defaultAudienceId,
+		audiences
 	};
 }
-const defaultSections = (legacy, options) => {
-	const footerVisible = options.footerVisible ?? true;
-	return [
-		{
-			id: unsafeAsFooterModuleId("brand"),
-			kind: "brand",
-			heading: null,
-			selected: footerVisible,
-			showLogo: options.brand?.showLogo ?? true,
-			showTitle: options.brand?.showTitle ?? true
-		},
-		{
-			id: unsafeAsFooterModuleId("navigation"),
-			kind: "navigation",
-			heading: null,
-			selected: footerVisible,
-			source: {
-				kind: "menu-role",
-				role: "main"
-			}
-		},
-		{
-			id: unsafeAsFooterModuleId("legal-navigation"),
-			kind: "legal-navigation",
-			heading: null,
-			selected: false,
-			source: {
-				kind: "menu-role",
-				role: "legal-policy"
-			}
-		},
-		{
-			id: unsafeAsFooterModuleId("business-address"),
-			kind: "business-address",
-			heading: null,
-			selected: footerVisible && legacy.showBusinessAddress === true,
-			source: { kind: "business-address" }
-		},
-		{
-			id: unsafeAsFooterModuleId("contact"),
-			kind: "contact",
-			heading: null,
-			selected: false,
-			source: { kind: "public-profile" }
-		},
-		{
-			id: unsafeAsFooterModuleId("opening-hours"),
-			kind: "opening-hours",
-			heading: null,
-			selected: false,
-			source: { kind: "public-profile" }
-		},
-		{
-			id: unsafeAsFooterModuleId("social-links"),
-			kind: "social-links",
-			heading: null,
-			selected: false,
-			source: { kind: "public-profile" }
-		},
-		{
-			id: unsafeAsFooterModuleId("supporting-text"),
-			kind: "supporting-text",
-			heading: null,
-			selected: footerVisible && isRichText(legacy.bodyText),
-			content: isRichText(legacy.bodyText) ? legacy.bodyText : null
-		},
-		{
-			id: unsafeAsFooterModuleId("legal"),
-			kind: "legal",
-			heading: null,
-			selected: footerVisible && isRichText(legacy.bottomText),
-			content: isRichText(legacy.bottomText) ? legacy.bottomText : null
-		}
-	];
-};
-function normalizeLegacyFooterContentToV1(value, options = {}) {
-	if (!isRecord$1(value)) {
-		return err({
-			code: "invalid_shape",
-			path: "",
-			message: "Legacy footer content must be an object."
+function parseMailchimpInterests(value) {
+	const interests = [];
+	for (const interest of value) {
+		if (!isRecord$1(interest)) return null;
+		const id = parseMailchimpInterestId(interest.id);
+		const name = parseName(interest.name);
+		const categoryName = parseName(interest.categoryName);
+		if (id === null || name === null || categoryName === null) return null;
+		interests.push({
+			id,
+			name,
+			categoryName
 		});
 	}
-	return validateFooterComposition({
-		schemaVersion: 1,
-		sections: defaultSections(value, options)
-	});
+	return interests;
+}
+function parseNamedItems(value, parseId) {
+	if (!Array.isArray(value)) return null;
+	const items = [];
+	for (const item of value) {
+		if (!isRecord$1(item)) return null;
+		const id = parseId(item.id);
+		const name = parseName(item.name);
+		if (id === null || name === null) return null;
+		items.push({
+			id,
+			name
+		});
+	}
+	return items;
+}
+function parseName(value) {
+	if (typeof value !== "string") return null;
+	const name = value.trim();
+	return name.length > 0 ? name : null;
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalidRuntimeContext() {
+	return err({ tag: "invalid_mailing_list_runtime_context" });
 }
 
 //#endregion
-//#region ../core/src/footer-navigation-layout.ts
-const footerNavigationLayouts = ["stack", "inline-wrap"];
-const defaultFooterNavigationLayout = "inline-wrap";
-function normalizeFooterNavigationLayout(value) {
-	return value === "stack" ? "stack" : defaultFooterNavigationLayout;
+//#region ../core/src/mailing-list-submission.ts
+const MAILING_LIST_SUBMISSION_BUDGET_MS = 1e4;
+function parseMailingListBlockId(value) {
+	const parsed = typeof value === "string" ? value.trim() : "";
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(parsed) ? parsed : null;
+}
+function parseMailingListSignedSourceToken(value) {
+	const parsed = typeof value === "string" ? value.trim() : "";
+	return /^[A-Za-z0-9._~-]{16,1000}$/u.test(parsed) ? parsed : null;
+}
+function parseMailingListSdkFooterBlockId(value) {
+	const parsed = typeof value === "string" ? value.trim() : "";
+	return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(parsed) ? parsed : null;
+}
+function parseMailingListSdkContentHash(value) {
+	const parsed = typeof value === "string" ? value.trim() : "";
+	return /^[a-f0-9]{16}$/iu.test(parsed) ? parsed : null;
+}
+function parseMailingListContentVersionId(value) {
+	const parsed = parseContentVersionId(value);
+	return parsed.ok ? parsed.value : null;
+}
+function parseMailingListFooterRevision(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function buildMailingListSignupBlockSourceRef(blockId) {
+	const parsed = parseMailingListBlockId(blockId);
+	return parsed !== null ? {
+		tag: "block_ref",
+		blockId: parsed
+	} : null;
+}
+function parseMailingListSignupProfile(form, input) {
+	const email = normalizeSubscriberEmail(input.email);
+	if (email === null) return {
+		ok: false,
+		error: { tag: "invalid_email" }
+	};
+	const phone = form.includeOptionalPhone ? {
+		tag: "collected",
+		value: normalizeOptionalValue(input.phone)
+	} : { tag: "not_collected" };
+	switch (form.fields.preset) {
+		case "emailOnly": return {
+			ok: true,
+			value: {
+				preset: "emailOnly",
+				email,
+				phone
+			}
+		};
+		case "emailName": {
+			const name = resolveProfileField("name", form.fields.name, input.name);
+			return name.ok ? {
+				ok: true,
+				value: {
+					preset: "emailName",
+					email,
+					phone,
+					name: name.value
+				}
+			} : name;
+		}
+		case "emailFirstLast": {
+			const firstName = resolveProfileField("first_name", form.fields.firstName, input.firstName);
+			if (!firstName.ok) return firstName;
+			const lastName = resolveProfileField("last_name", form.fields.lastName, input.lastName);
+			return lastName.ok ? {
+				ok: true,
+				value: {
+					preset: "emailFirstLast",
+					email,
+					phone,
+					firstName: firstName.value,
+					lastName: lastName.value
+				}
+			} : lastName;
+		}
+		case "emailNameCompany": {
+			const name = resolveProfileField("name", form.fields.name, input.name);
+			if (!name.ok) return name;
+			const company = resolveProfileField("company", form.fields.company, input.company);
+			return company.ok ? {
+				ok: true,
+				value: {
+					preset: "emailNameCompany",
+					email,
+					phone,
+					name: name.value,
+					company: company.value
+				}
+			} : company;
+		}
+	}
+}
+function resolveProfileField(field, requirement, input) {
+	const value = normalizeOptionalValue(input);
+	if (requirement === "required") {
+		return value === null ? {
+			ok: false,
+			error: {
+				tag: "required_field_missing",
+				field
+			}
+		} : {
+			ok: true,
+			value: {
+				requirement: "required",
+				value
+			}
+		};
+	}
+	return {
+		ok: true,
+		value: {
+			requirement: "optional",
+			value
+		}
+	};
+}
+function normalizeSubscriberEmail(value) {
+	const normalized = value.trim().toLowerCase();
+	const at = normalized.indexOf("@");
+	return normalized.length <= 320 && at > 0 && at === normalized.lastIndexOf("@") && at < normalized.length - 1 ? normalized : null;
+}
+function normalizeOptionalValue(value) {
+	const normalized = value?.trim() ?? "";
+	return normalized.length > 0 ? normalized : null;
+}
+function toMailingListPublicSignupResponse(result) {
+	if (result.ok) {
+		return result.acknowledgement.tag === "subscribed" ? { tag: "subscribed" } : { tag: "confirmation_required" };
+	}
+	if (result.error.tag === "profile_rejected") {
+		return {
+			tag: "invalid_input",
+			reason: "profile_rejected"
+		};
+	}
+	return result.error.tag === "uncertain" ? {
+		tag: "uncertain",
+		reason: result.error.reason
+	} : {
+		tag: "unavailable",
+		reason: result.error.tag
+	};
 }
 
 //#endregion
@@ -4653,61 +6011,161 @@ function foldSiteRouteTarget(target, cases) {
 }
 
 //#endregion
-//#region ../core/src/planner.ts
-function plannerNoChange(details = {}) {
-	return {
-		...details,
-		tag: "no_change"
-	};
+//#region ../core/src/whole-series-run-schedule.ts
+/**
+* A session that is not happening.
+*
+* Exported because every surface that renders a run's schedule has to mark the
+* same weeks, and a second copy of the string is a second chance to disagree.
+*/
+const CANCELLED_SESSION_STATUS = "cancelled";
+/** A run the organiser called off. Spelled the same, about a different row. */
+const CANCELLED_SERIES_STATUS = "cancelled";
+function sessionStartMs(session) {
+	return Date.parse(session.startsAt);
 }
-function plannerUpdate(details = {}) {
-	return {
-		...details,
-		tag: "update"
-	};
+/**
+* The run's sessions that still count, in schedule order.
+*
+* Sessions whose start cannot be read are dropped rather than sorted to an
+* arbitrary end: an unparseable date is not a date a visitor can attend.
+*/
+function orderedLiveRunSessions(sessions) {
+	return sessions.filter((session) => session.status !== CANCELLED_SESSION_STATUS && Number.isFinite(sessionStartMs(session))).sort((left, right) => sessionStartMs(left) - sessionStartMs(right));
 }
-/** Identity at runtime; marks a planner-derived patch as shallow readonly. */
-function plannerPatch(patch) {
-	return patch;
+/** When the first session a visitor could attend begins. */
+function firstLiveRunSessionStartMs(sessions) {
+	const first = orderedLiveRunSessions(sessions)[0];
+	return first === undefined ? null : sessionStartMs(first);
 }
-/** Default clock for production callers that do not inject time explicitly. */
-const systemPlanningClock = { now: () => Date.now() };
-/** Resolve current time from an explicit timestamp, injected clock, or system clock. */
-function resolvePlanningNow(input = {}) {
-	if (typeof input.now === "number") {
-		return input.now;
-	}
-	return (input.clock ?? systemPlanningClock).now();
+/**
+* Booking stays open until the run's first surviving session has started.
+*
+* There has to be something left to sell: a run with no schedule at all, or one
+* whose every session has been cancelled, is closed rather than open. Adding a
+* future session opens it again, subject to the usual status, visibility and
+* admission rules.
+*/
+function isWholeSeriesRegistrationOpen(sessions, now) {
+	const firstStart = firstLiveRunSessionStartMs(sessions);
+	return firstStart !== null && firstStart > now.getTime();
 }
-/** Resolve current time as a Date from an explicit Date, injected clock, or system clock. */
-function resolvePlanningNowDate(input = {}) {
-	if (input.now !== undefined) {
-		return input.now;
-	}
-	return new Date((input.clock ?? systemPlanningClock).now());
+/**
+* Where the run sits in its own life, independent of any one session.
+*
+* A cancelled or completed series status says so whatever the dates read.
+* Otherwise the surviving schedule decides: before the first session it is
+* upcoming, after the last session ends it is complete, and in between it is
+* under way. A run with nothing left to attend is `upcoming` and never
+* `in_progress` — an empty schedule has not started.
+*/
+function resolveWholeSeriesRunLifecycle(input, now) {
+	if (input.seriesStatus === CANCELLED_SERIES_STATUS) return "cancelled";
+	if (input.seriesStatus === "completed") return "completed";
+	const live = orderedLiveRunSessions(input.sessions);
+	const first = live[0];
+	const last = live[live.length - 1];
+	if (first === undefined || last === undefined) return "upcoming";
+	if (sessionStartMs(first) > now.getTime()) return "upcoming";
+	return Date.parse(last.endsAt) < now.getTime() ? "completed" : "in_progress";
 }
 /**
-* Resolve a Date-compatible planner input.
+* Whether a prepared run is still inviting bookings at render time.
 *
-* Precedence: bare Date, `{ now }`, `{ clock }`, then `systemPlanningClock`.
-* Explicit Date inputs are returned by reference, not cloned.
+* `lifecycle` and `enrollmentOpen` come from the projection; the first session
+* start is the one fact re-read against `now`, because that is the boundary a
+* cached page can cross while it sits in front of a visitor.
 */
-function resolvePlanningDateInput(input = {}) {
-	if (input instanceof Date) {
-		return input;
+function resolveWholeSeriesBookingPhase(run, now) {
+	switch (run.lifecycle) {
+		case "cancelled": return {
+			kind: "closed",
+			reason: "cancelled"
+		};
+		case "in_progress": return {
+			kind: "closed",
+			reason: "in-progress"
+		};
+		case "completed": return {
+			kind: "closed",
+			reason: "completed"
+		};
+		case "upcoming": {
+			if (firstLiveRunSessionStartMs(run.sessions) === null) {
+				return {
+					kind: "closed",
+					reason: "no-sessions"
+				};
+			}
+			if (!isWholeSeriesRegistrationOpen(run.sessions, now)) {
+				return {
+					kind: "closed",
+					reason: "in-progress"
+				};
+			}
+			return run.enrollmentOpen ? { kind: "open" } : {
+				kind: "closed",
+				reason: "enrolment-closed"
+			};
+		}
 	}
-	return resolvePlanningNowDate(input);
 }
-/** Build an enabled selection while preserving literal value types. */
-function enabledSelection(value) {
+
+//#endregion
+//#region ../core/src/public-read-cache-contract.ts
+const PUBLIC_AVAILABILITY_FRESHNESS_SECONDS = 60;
+const PUBLIC_CONTENT_FRESHNESS_SECONDS = 3600;
+function availability(transport) {
 	return {
-		enabled: true,
-		value
+		kind: "live",
+		reason: "booking_correctness",
+		freshness: "availability",
+		transport
 	};
 }
-/** Build a disabled selection. */
-function disabledSelection() {
-	return { enabled: false };
+function content(tags, transport = "direct") {
+	return {
+		kind: "tagged",
+		tags,
+		freshness: "content",
+		transport
+	};
+}
+/** The single classification authority for cacheable public reads. */
+const PUBLIC_READ_CACHE_POLICIES = {
+	listPublishedEntries: content(["published_content"]),
+	getPublishedEntryPreview: content(["published_content"]),
+	listPublicEvents: availability("direct"),
+	listPublicEventCalendarWindow: availability("direct"),
+	listPublicRecurringSchedule: availability("batch_only"),
+	getPublicEventDetails: availability("batch_only"),
+	resolveEventSubroute: availability("direct"),
+	listPublicRouteCandidates: content(["published_content"], "batch_only"),
+	listPublicTeamMembers: content(["public_team_members"]),
+	listPublicProducts: availability("direct"),
+	listPublicPasses: availability("direct"),
+	listPublicMemberships: availability("direct"),
+	getPublicFormById: content(["site_forms"]),
+	getPublicBookingServices: availability("direct"),
+	getPublicBookingService: availability("direct"),
+	getPublicBookingResourcesReference: availability("direct"),
+	getPublicBookingAvailableDates: availability("direct"),
+	getPublicBookingAvailableSlots: availability("direct"),
+	getPublicWeeklySlotAvailability: availability("direct"),
+	listPublicForms: content(["site_forms"]),
+	checkRedirect: content([]),
+	getPublicRoutableContent: content(["published_content"]),
+	getPublicSitemapRoutes: content(["published_content"])
+};
+const PUBLIC_READ_ENDPOINT_SET = new Set(Object.keys(PUBLIC_READ_CACHE_POLICIES));
+function isPublicReadEndpoint(endpoint) {
+	return PUBLIC_READ_ENDPOINT_SET.has(endpoint);
+}
+function getPublicReadCachePolicy(endpoint) {
+	return PUBLIC_READ_CACHE_POLICIES[endpoint];
+}
+function publicReadFreshnessSeconds(endpoint) {
+	return getPublicReadCachePolicy(endpoint).freshness === "availability" ? PUBLIC_AVAILABILITY_FRESHNESS_SECONDS : PUBLIC_CONTENT_FRESHNESS_SECONDS;
 }
 
 //#endregion
@@ -4793,13 +6251,13 @@ const BOOKING_DEFAULTS_BY_BEHAVIOUR = {
 		memberships: "off"
 	}
 };
-function verticalBookingPreset(id, verticalId, canonicalBehaviour, label, pluralLabel, description, availability = "onboarding") {
+function verticalBookingPreset(id, verticalId, canonicalBehaviour, label, pluralLabel, description, availability$1 = "onboarding") {
 	return {
 		id,
 		verticalId,
 		canonicalBehaviour,
 		engine: BOOKING_ENGINE_BY_BEHAVIOUR[canonicalBehaviour],
-		availability,
+		availability: availability$1,
 		label,
 		pluralLabel,
 		description
@@ -5153,12 +6611,12 @@ const VERTICAL_PRESET_AVAILABILITIES = [
 	"future"
 ];
 function getVerticalPresetsForVertical(verticalId, options) {
-	const availability = options?.availability;
+	const availability$1 = options?.availability;
 	return VERTICAL_BOOKING_PRESETS.filter((presetDefinition) => {
 		if (presetDefinition.verticalId !== verticalId) return false;
-		if (!availability) return true;
-		if (availability === "selectable") return presetDefinition.availability !== "future";
-		return presetDefinition.availability === availability;
+		if (!availability$1) return true;
+		if (availability$1 === "selectable") return presetDefinition.availability !== "future";
+		return presetDefinition.availability === availability$1;
 	});
 }
 function getOnboardingPresetsForVertical(verticalId) {
@@ -5382,4 +6840,62 @@ function orderPresetIdsForVertical(verticalId, presetIds) {
 }
 
 //#endregion
-export { parseEventSeriesId as $, normalizeLocationAddressText as A, ok as At, parseUtcIsoDateTimeString as B, parseNewsletterSignupDestinationProvider as C, unsafeAsSiteScopedStoragePath as Ct, mapNonEmptyArray as D, unsafeAsUploadSessionId as Dt, fromArray as E, unsafeAsStoragePath as Et, formatLocalScheduleDate as F, parseEventPageSurfaceSubject as G, toScheduledBookingDateRange as H, formatLocalScheduleTime as I, publicEventPricingCurrency as J, formatBookingPriceDisplay as K, getBookingLocalDateKey as L, formatBookingDate as M, formatBookingDateParts as N, hasText as O, unsafeAsUserId as Ot, formatBookingTime as P, parseApiKeyId as Q, getLocalScheduleDate as R, parseNewsletterSignupAuthoringDestinationValue as S, unsafeAsSiteId as St, assertAllowedPublicUrl as T, unsafeAsStorageBucketName as Tt, toScheduledBookingDateTime as U, toBookingTimeZone as V, parseBookingTimeZone as W, formatCurrencyAmount as X, publicEventPricingType as Y, assertNever as Z, parseFooterCompositionV1 as _, unsafeAsPositiveByteCount as _t, parseVerticalPresetId as a, unsafeAsBookingRequirementId as at, parseMailchimpTagName as b, unsafeAsSafeDownloadFilename as bt, EVENT_PRESET_VALUES as c, unsafeAsDemoCapability as ct, resolvePlanningDateInput as d, unsafeAsEventOfferingId as dt, parseMediaAssetId as et, createSecret as f, unsafeAsEventSeriesId as ft, footerNavigationLayouts as g, unsafeAsOriginalFilename as gt, stableJsonStringify as h, unsafeAsOccurrenceId as ht, parseVerticalId as i, unsafeAsAppointmentResourceId as it, toLocationCoordinates as j, isPresent as k, err as kt, ORDINARY_EVENT_PRESET_VALUES as l, unsafeAsDetectedMimeType as lt, parseManagementKey as m, unsafeAsMediaAssetId as mt, canonicalizeConfiguredBookingVerticalConfig as n, parseSiteId as nt, resolveSiteVerticalBookingConfig as o, unsafeAsBookingSessionId as ot, exposeSecret as p, unsafeAsFileChecksumSha256 as pt, formatEventPricing as q, isEventSeriesVerticalPresetDefinition as r, parseUserId as rt, DEFAULT_EVENT_TYPE_PRESETS as s, unsafeAsDeclaredMimeType as st, areConfiguredBookingVerticalConfigsEqual as t, parsePageId as tt, SURFACE_EVENT_PRESET_VALUES as u, unsafeAsEntitlementId as ut, parseFooterModuleId as v, unsafeAsPositiveSeconds as vt, isCanonicalRichTextDoc as w, unsafeAsStaffMemberId as wt, parseNewsletterListId as x, unsafeAsSiteFontId as xt, parseMailchimpAudienceId as y, unsafeAsProductId as yt, getLocalScheduleTime as z };
+//#region ../core/src/navigation-locations.ts
+/** The only places a site's navigation can be displayed. */
+const NAVIGATION_LOCATIONS = [
+	"main",
+	"footer",
+	"legal"
+];
+const NAVIGATION_LOCATION_DESCRIPTORS = {
+	main: {
+		location: "main",
+		label: "Main navigation",
+		description: "Links shown in the site header when header navigation is enabled."
+	},
+	footer: {
+		location: "footer",
+		label: "Footer links",
+		description: "Links shown in the main footer links section when it is enabled."
+	},
+	legal: {
+		location: "legal",
+		label: "Legal links",
+		description: "Smaller footer links for privacy, terms and other policies."
+	}
+};
+function isNavigationLocation(value) {
+	return typeof value === "string" && NAVIGATION_LOCATIONS.includes(value);
+}
+/** Parse all rows for one site into a complete fixed-location record. */
+function parseSiteNavigationLocations(rows) {
+	const locations = {};
+	for (const [index, row] of rows.entries()) {
+		if (!isNavigationLocation(row.location)) {
+			return err({
+				kind: "invalid_location",
+				index,
+				value: row.location
+			});
+		}
+		if (Object.prototype.hasOwnProperty.call(locations, row.location)) {
+			return err({
+				kind: "duplicate_location",
+				location: row.location
+			});
+		}
+		locations[row.location] = row.value;
+	}
+	for (const location of NAVIGATION_LOCATIONS) {
+		if (!Object.prototype.hasOwnProperty.call(locations, location)) {
+			return err({
+				kind: "missing_location",
+				location
+			});
+		}
+	}
+	return ok(locations);
+}
+
+//#endregion
+export { publicEventPricingDisplay as $, assertAllowedPublicUrl as A, unsafeAsSiteFontId as At, getBookingLocalDateKey as B, parseMailingListSignedSourceToken as C, unsafeAsMediaAssetId as Ct, parseFooterCompositionV1 as D, unsafeAsPositiveSeconds as Dt, footerNavigationLayouts as E, unsafeAsPositiveByteCount as Et, formatBookingDate as F, unsafeAsStoragePath as Ft, toScheduledBookingDateRange as G, getLocalScheduleTime as H, formatBookingDateParts as I, unsafeAsUploadSessionId as It, parseEventPageSurfaceSubject as J, toScheduledBookingDateTime as K, formatBookingTime as L, unsafeAsUserId as Lt, normalizeLocationAddressText as M, unsafeAsSiteScopedStoragePath as Mt, toLocationCoordinates as N, unsafeAsStaffMemberId as Nt, parseMailingListPlacementTargeting as O, unsafeAsProductId as Ot, buildBookingUtcDateWindow as P, unsafeAsStorageBucketName as Pt, publicEventPricingCurrency as Q, formatLocalScheduleDate as R, err as Rt, parseMailingListBlockId as S, unsafeAsFileChecksumSha256 as St, planMailingListChoicePresentation as T, unsafeAsOriginalFilename as Tt, parseUtcIsoDateTimeString as U, getLocalScheduleDate as V, toBookingTimeZone as W, formatEventPricing as X, formatBookingPriceDisplay as Y, isPublicEventPricingOptionDisplayable as Z, createSecret as _, unsafeAsDemoCapability as _t, parseVerticalId as a, formatCurrencyAmount as at, stableJsonStringify as b, unsafeAsEventOfferingId as bt, DEFAULT_EVENT_TYPE_PRESETS as c, parseEventSeriesId as ct, SURFACE_EVENT_PRESET_VALUES as d, parseSiteId as dt, publicEventPricingType as et, WHOLE_SERIES_EVENT_PRESET_VALUES as f, parseUserId as ft, resolveWholeSeriesBookingPhase as g, unsafeAsDeclaredMimeType as gt, orderedLiveRunSessions as h, unsafeAsBookingSessionId as ht, isEventSeriesVerticalPresetDefinition as i, mapNonEmptyArray as it, isPresent as j, unsafeAsSiteId as jt, isCanonicalRichTextDoc as k, unsafeAsSafeDownloadFilename as kt, EVENT_PRESET_VALUES as l, parseMediaAssetId as lt, CANCELLED_SESSION_STATUS as m, unsafeAsBookingRequirementId as mt, areConfiguredBookingVerticalConfigsEqual as n, resolvePricingOptionsPriceDisplay as nt, parseVerticalPresetId as o, assertNever as ot, publicReadFreshnessSeconds as p, unsafeAsAppointmentResourceId as pt, parseBookingTimeZone as q, canonicalizeConfiguredBookingVerticalConfig as r, fromArray as rt, resolveSiteVerticalBookingConfig as s, parseApiKeyId as st, NAVIGATION_LOCATIONS as t, resolveExactOrFreePriceDisplay as tt, ORDINARY_EVENT_PRESET_VALUES as u, parsePageId as ut, exposeSecret as v, unsafeAsDetectedMimeType as vt, parseMailingListRuntimeContext as w, unsafeAsOccurrenceId as wt, buildMailingListSignupBlockSourceRef as x, unsafeAsEventSeriesId as xt, parseManagementKey as y, unsafeAsEntitlementId as yt, formatLocalScheduleTime as z, ok as zt };