riverbankcms 0.5.0 → 0.6.0

package/dist/{src-DKm0bLEA.mjs → src-X9oZOIoK.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,62 +580,559 @@ function formatCurrencyAmount(amountCents, currency, options) {
 	}
 }
 
+//#endregion
+//#region ../core/src/money-input.ts
+function unsafeAsCents(value) {
+	return value;
+}
+function unsafeAsNonNegativeCents(value) {
+	return value;
+}
+function unsafeAsPositiveCents(value) {
+	return value;
+}
+function unwrapCents(value) {
+	return value;
+}
+function isWholeCents(value) {
+	return Number.isFinite(value) && Number.isInteger(value);
+}
+function isNonNegativeWholeCents(value) {
+	return isWholeCents(value) && value >= 0;
+}
+function isPositiveWholeCents(value) {
+	return isWholeCents(value) && value > 0;
+}
+/**
+* Normalizes a derived amount to signed whole cents. Use parse*Cents for
+* untrusted input that should fail instead of truncating or clamping.
+*/
+function toCents(value) {
+	return unsafeAsCents(Math.trunc(value));
+}
+/**
+* Normalizes a derived amount to non-negative whole cents. This intentionally
+* clamps negatives to zero; use parseNonNegativeCents for validation.
+*/
+function toNonNegativeCents(value) {
+	return unsafeAsNonNegativeCents(Math.max(0, Math.trunc(value)));
+}
+function parseCents(value) {
+	if (!Number.isFinite(value)) {
+		return err({ kind: "invalid-number" });
+	}
+	if (!Number.isInteger(value)) {
+		return err({ kind: "not-whole-cents" });
+	}
+	return ok(unsafeAsCents(value));
+}
+function parseNonNegativeCents(value) {
+	const parsed = parseCents(value);
+	if (!parsed.ok) {
+		return parsed;
+	}
+	if (parsed.value < 0) {
+		return err({ kind: "negative" });
+	}
+	return ok(unsafeAsNonNegativeCents(parsed.value));
+}
+function parsePositiveCents(value) {
+	const parsed = parseNonNegativeCents(value);
+	if (!parsed.ok) {
+		return parsed;
+	}
+	if (parsed.value === 0) {
+		return err({ kind: "zero-not-allowed" });
+	}
+	return ok(unsafeAsPositiveCents(parsed.value));
+}
+function normalizeMoneyInput(value, options) {
+	return (options.stripFormatting === true ? value.replace(/[^0-9.-]/g, "") : value).trim();
+}
+function parseFiniteMoneyAmount(value, options) {
+	const normalized = normalizeMoneyInput(value, options);
+	if (normalized.length === 0) {
+		return err({ kind: "empty" });
+	}
+	const amount = Number(normalized);
+	if (!Number.isFinite(amount)) {
+		return err({ kind: "invalid-number" });
+	}
+	return ok(amount);
+}
+function roundMoneyAmountToCents(amount) {
+	return Math.round(amount * 100);
+}
+function parsePositiveMoneyInputToCents(value, options = {}) {
+	const parsed = parseFiniteMoneyAmount(value, options);
+	if (!parsed.ok) {
+		return parsed;
+	}
+	if (parsed.value < 0) {
+		return err({ kind: "negative" });
+	}
+	const amountCents = roundMoneyAmountToCents(parsed.value);
+	if (amountCents <= 0) {
+		return err({ kind: "zero-not-allowed" });
+	}
+	return ok(unsafeAsPositiveCents(amountCents));
+}
+function parseNonNegativeMoneyInputToCents(value, options = {}) {
+	const parsed = parseFiniteMoneyAmount(value, options);
+	if (!parsed.ok) {
+		return parsed;
+	}
+	if (parsed.value < 0) {
+		return err({ kind: "negative" });
+	}
+	return ok(unsafeAsNonNegativeCents(roundMoneyAmountToCents(parsed.value)));
+}
+function parseMoneyInputToCents(value, options = {}) {
+	const parsed = parseFiniteMoneyAmount(value, options);
+	if (!parsed.ok) {
+		return null;
+	}
+	if (options.allowZero === true ? parsed.value < 0 : parsed.value <= 0) {
+		return null;
+	}
+	return roundMoneyAmountToCents(parsed.value);
+}
+function formatMoneyInputFromCents(amountCents) {
+	if (typeof amountCents !== "number" || !Number.isFinite(amountCents)) {
+		return "";
+	}
+	const sign = amountCents < 0 ? "-" : "";
+	const absoluteCents = Math.abs(Math.trunc(amountCents));
+	const units = Math.floor(absoluteCents / 100);
+	const fractional = String(absoluteCents % 100).padStart(2, "0");
+	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 = parseOptionAvailability(input);
+	const issues = [
+		identity,
+		commercials,
+		availability
+	].flatMap((result) => result.ok ? [] : [result.error]);
+	if (!identity.ok || !commercials.ok || !availability.ok) {
+		const nonEmptyIssues = fromReadonlyArray(issues);
+		return err(nonEmptyIssues.ok ? nonEmptyIssues.value : oneIssue({ kind: "invalid_object" }));
+	}
+	return ok({
+		...identity.value,
+		...commercials.value,
+		...availability.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
-const EVENT_PRICING_MODES = [
-	"single",
-	"ticket_types",
-	"sliding_scale"
-];
-function isEventPricingMode(value) {
-	return typeof value === "string" && EVENT_PRICING_MODES.includes(value);
+/** 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) {
-	return pricing.display;
+	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 "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 "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 "drop_in":
-		case "free_registration":
-		case "single_paid":
-		case "ticket_types":
+		case "free":
+		case "single":
+		case "tiered":
 		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;
+	return pricing.kind === "single" ? pricing.amount : null;
 }
-function publicEventPricingMode(pricing) {
+function publicEventPricingStrategy(pricing) {
 	switch (pricing.kind) {
-		case "single_paid":
-		case "free_registration": return "single";
-		case "ticket_types": return "ticket_types";
+		case "single": return "single";
+		case "free": return "free";
+		case "tiered": return "tiered";
 		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 publicEventPricingOptions(pricing) {
+	return pricing.kind === "tiered" ? pricing.options : [];
 }
 function isFreePublicEventPriceDisplay(display) {
 	switch (display.kind) {
 		case "free": return true;
-		case "whole_series": return display.display.kind === "free";
 		case "exact":
 		case "from":
 		case "range":
@@ -602,15 +1141,96 @@ function isFreePublicEventPriceDisplay(display) {
 		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);
+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);
 	}
 }
 /**
@@ -629,7 +1249,6 @@ function formatBookingPriceDisplay(display, 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);
 	}
 }
@@ -640,17 +1259,48 @@ function formatEventPricing(pricing, options = {}) {
 
 //#endregion
 //#region ../core/src/event-page-surface-subject.ts
-function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope) {
+function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope, eventDestinationMode) {
+	const mode = eventDestinationMode ? { eventDestinationMode } : {};
 	return bookingScope === "whole_series" ? {
 		kind: "eventSeries",
 		eventSeriesId,
 		bookingScope,
-		isWholeSeriesBooking: true
+		isWholeSeriesBooking: true,
+		...mode
 	} : {
 		kind: "eventSeries",
 		eventSeriesId,
-		bookingScope
+		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$6(value)) return err({ kind: "notObject" });
@@ -669,7 +1319,7 @@ function parseEventPageSurfaceSubject(value) {
 					bookingScope: value.bookingScope
 				});
 			}
-			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
+			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope, parseEventPageSurfaceDestinationMode(value.eventDestinationMode)));
 		}
 		case "eventOffering": {
 			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
@@ -679,28 +1329,26 @@ function parseEventPageSurfaceSubject(value) {
 					error: eventOfferingId.error
 				});
 			}
-			if (!Array.isArray(value.availableEventSeriesIds)) {
+			if (!Array.isArray(value.catalogueEventSeriesIds)) {
 				return err({
-					kind: "unsupportedSubject",
-					subjectKind: value.kind
+					kind: "invalidEventOfferingCatalogue",
+					catalogue: value.catalogueEventSeriesIds
 				});
 			}
-			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);
+			if (value.bookingScope !== "single_occurrence" && value.bookingScope !== "whole_series") {
+				return err({
+					kind: "invalidEventOfferingBookingScope",
+					bookingScope: value.bookingScope
+				});
 			}
-			return ok({
-				kind: "eventOffering",
-				eventOfferingId: eventOfferingId.value,
-				availableEventSeriesIds: parsedSeriesIds
-			});
+			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",
@@ -711,136 +1359,22 @@ function parseEventPageSurfaceSubject(value) {
 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) {
-	return value;
-}
-function unsafeAsNonNegativeCents(value) {
-	return value;
-}
-function unsafeAsPositiveCents(value) {
-	return value;
-}
-function unwrapCents(value) {
-	return value;
-}
-function isWholeCents(value) {
-	return Number.isFinite(value) && Number.isInteger(value);
-}
-function isNonNegativeWholeCents(value) {
-	return isWholeCents(value) && value >= 0;
-}
-function isPositiveWholeCents(value) {
-	return isWholeCents(value) && value > 0;
-}
-/**
-* Normalizes a derived amount to signed whole cents. Use parse*Cents for
-* untrusted input that should fail instead of truncating or clamping.
-*/
-function toCents(value) {
-	return unsafeAsCents(Math.trunc(value));
-}
-/**
-* Normalizes a derived amount to non-negative whole cents. This intentionally
-* clamps negatives to zero; use parseNonNegativeCents for validation.
-*/
-function toNonNegativeCents(value) {
-	return unsafeAsNonNegativeCents(Math.max(0, Math.trunc(value)));
-}
-function parseCents(value) {
-	if (!Number.isFinite(value)) {
-		return err({ kind: "invalid-number" });
-	}
-	if (!Number.isInteger(value)) {
-		return err({ kind: "not-whole-cents" });
-	}
-	return ok(unsafeAsCents(value));
-}
-function parseNonNegativeCents(value) {
-	const parsed = parseCents(value);
-	if (!parsed.ok) {
-		return parsed;
-	}
-	if (parsed.value < 0) {
-		return err({ kind: "negative" });
-	}
-	return ok(unsafeAsNonNegativeCents(parsed.value));
-}
-function parsePositiveCents(value) {
-	const parsed = parseNonNegativeCents(value);
-	if (!parsed.ok) {
-		return parsed;
-	}
-	if (parsed.value === 0) {
-		return err({ kind: "zero-not-allowed" });
-	}
-	return ok(unsafeAsPositiveCents(parsed.value));
-}
-function normalizeMoneyInput(value, options) {
-	return (options.stripFormatting === true ? value.replace(/[^0-9.-]/g, "") : value).trim();
-}
-function parseFiniteMoneyAmount(value, options) {
-	const normalized = normalizeMoneyInput(value, options);
-	if (normalized.length === 0) {
-		return err({ kind: "empty" });
-	}
-	const amount = Number(normalized);
-	if (!Number.isFinite(amount)) {
-		return err({ kind: "invalid-number" });
-	}
-	return ok(amount);
-}
-function roundMoneyAmountToCents(amount) {
-	return Math.round(amount * 100);
-}
-function parsePositiveMoneyInputToCents(value, options = {}) {
-	const parsed = parseFiniteMoneyAmount(value, options);
-	if (!parsed.ok) {
-		return parsed;
-	}
-	if (parsed.value < 0) {
-		return err({ kind: "negative" });
-	}
-	const amountCents = roundMoneyAmountToCents(parsed.value);
-	if (amountCents <= 0) {
-		return err({ kind: "zero-not-allowed" });
-	}
-	return ok(unsafeAsPositiveCents(amountCents));
-}
-function parseNonNegativeMoneyInputToCents(value, options = {}) {
-	const parsed = parseFiniteMoneyAmount(value, options);
-	if (!parsed.ok) {
-		return parsed;
-	}
-	if (parsed.value < 0) {
-		return err({ kind: "negative" });
-	}
-	return ok(unsafeAsNonNegativeCents(roundMoneyAmountToCents(parsed.value)));
-}
-function parseMoneyInputToCents(value, options = {}) {
-	const parsed = parseFiniteMoneyAmount(value, options);
-	if (!parsed.ok) {
-		return null;
-	}
-	if (options.allowZero === true ? parsed.value < 0 : parsed.value <= 0) {
-		return null;
+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 roundMoneyAmountToCents(parsed.value);
+	return ok(parsed);
 }
-function formatMoneyInputFromCents(amountCents) {
-	if (typeof amountCents !== "number" || !Number.isFinite(amountCents)) {
-		return "";
-	}
-	const sign = amountCents < 0 ? "-" : "";
-	const absoluteCents = Math.abs(Math.trunc(amountCents));
-	const units = Math.floor(absoluteCents / 100);
-	const fractional = String(absoluteCents % 100).padStart(2, "0");
-	return `${sign}${units}.${fractional}`;
+function isRecord$6(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 //#endregion
@@ -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;
@@ -4653,61 +5174,104 @@ 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) {
-	return {
-		enabled: true,
-		value
-	};
-}
-/** Build a disabled selection. */
-function disabledSelection() {
-	return { enabled: false };
 }
 
 //#endregion
@@ -5382,4 +5946,4 @@ 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 };
+export { fromArray as $, normalizeLocationAddressText as A, unsafeAsStorageBucketName as At, getLocalScheduleTime as B, parseMailchimpTagName as C, unsafeAsPositiveSeconds as Ct, isCanonicalRichTextDoc as D, unsafeAsSiteId as Dt, parseNewsletterSignupDestinationProvider as E, unsafeAsSiteFontId as Et, formatBookingTime as F, ok as Ft, parseBookingTimeZone as G, toBookingTimeZone as H, formatLocalScheduleDate as I, formatEventPricing as J, parseEventPageSurfaceSubject as K, formatLocalScheduleTime as L, buildBookingUtcDateWindow as M, unsafeAsUploadSessionId as Mt, formatBookingDate as N, unsafeAsUserId as Nt, assertAllowedPublicUrl as O, unsafeAsSiteScopedStoragePath as Ot, formatBookingDateParts as P, err as Pt, publicEventPricingType as Q, getBookingLocalDateKey as R, parseMailchimpAudienceId as S, unsafeAsPositiveByteCount as St, parseNewsletterSignupAuthoringDestinationValue as T, unsafeAsSafeDownloadFilename as Tt, toScheduledBookingDateRange as U, parseUtcIsoDateTimeString as V, toScheduledBookingDateTime as W, publicEventPricingCurrency as X, isPublicEventPricingOptionDisplayable as Y, publicEventPricingDisplay as Z, parseManagementKey as _, unsafeAsEventSeriesId as _t, parseVerticalPresetId as a, parseMediaAssetId as at, parseFooterCompositionV1 as b, unsafeAsOccurrenceId as bt, EVENT_PRESET_VALUES as c, parseUserId as ct, WHOLE_SERIES_EVENT_PRESET_VALUES as d, unsafeAsBookingSessionId as dt, mapNonEmptyArray as et, CANCELLED_SESSION_STATUS as f, unsafeAsDeclaredMimeType as ft, exposeSecret as g, unsafeAsEventOfferingId as gt, createSecret as h, unsafeAsEntitlementId as ht, parseVerticalId as i, parseEventSeriesId as it, toLocationCoordinates as j, unsafeAsStoragePath as jt, isPresent as k, unsafeAsStaffMemberId as kt, ORDINARY_EVENT_PRESET_VALUES as l, unsafeAsAppointmentResourceId as lt, resolveWholeSeriesBookingPhase as m, unsafeAsDetectedMimeType as mt, canonicalizeConfiguredBookingVerticalConfig as n, assertNever as nt, resolveSiteVerticalBookingConfig as o, parsePageId as ot, orderedLiveRunSessions as p, unsafeAsDemoCapability as pt, formatBookingPriceDisplay as q, isEventSeriesVerticalPresetDefinition as r, parseApiKeyId as rt, DEFAULT_EVENT_TYPE_PRESETS as s, parseSiteId as st, areConfiguredBookingVerticalConfigsEqual as t, formatCurrencyAmount as tt, SURFACE_EVENT_PRESET_VALUES as u, unsafeAsBookingRequirementId as ut, stableJsonStringify as v, unsafeAsFileChecksumSha256 as vt, parseNewsletterListId as w, unsafeAsProductId as wt, parseFooterModuleId as x, unsafeAsOriginalFilename as xt, footerNavigationLayouts as y, unsafeAsMediaAssetId as yt, getLocalScheduleDate as z };